moparisthebest/hexchat
1
0
Fork 0
mirror of https://github.com/moparisthebest/hexchat synced 2024-11-22 09:12:22 -05:00
Code Issues Releases Wiki Activity

Nuke WMPA, not supported by Express

Browse Source
This commit is contained in:
Berke Viktor 2013-04-13 02:38:44 +02:00
parent cc1f2b2d27
commit 0c351c9cbc
56 changed files with 0 additions and 5102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

70
plugins/wmpa/ReadMe.txt
View File

@ -1,70 +0,0 @@
========================================================================
MICROSOFT FOUNDATION CLASS LIBRARY : wmpa
========================================================================
AppWizard has created this wmpa DLL for you. This DLL not only
demonstrates the basics of using the Microsoft Foundation classes but
is also a starting point for writing your DLL.
This file contains a summary of what you will find in each of the files that
make up your wmpa DLL.
wmpa.dsp
This file (the project file) contains information at the project level and
is used to build a single project or subproject. Other users can share the
project (.dsp) file, but they should export the makefiles locally.
wmpa.h
This is the main header file for the DLL. It declares the
CWmpaApp class.
wmpa.cpp
This is the main DLL source file. It contains the class CWmpaApp.
It also contains the OLE entry points required of inproc servers.
wmpa.odl
This file contains the Object Description Language source code for the
type library of your DLL.
wmpa.rc
This is a listing of all of the Microsoft Windows resources that the
program uses. It includes the icons, bitmaps, and cursors that are stored
in the RES subdirectory. This file can be directly edited in Microsoft
Visual C++.
wmpa.clw
This file contains information used by ClassWizard to edit existing
classes or add new classes. ClassWizard also uses this file to store
information needed to create and edit message maps and dialog data
maps and to create prototype member functions.
res\wmpa.rc2
This file contains resources that are not edited by Microsoft
Visual C++. You should place all resources not editable by
the resource editor in this file.
wmpa.def
This file contains information about the DLL that must be
provided to run with Microsoft Windows. It defines parameters
such as the name and description of the DLL. It also exports
functions from the DLL.
/////////////////////////////////////////////////////////////////////////////
Other standard files:
StdAfx.h, StdAfx.cpp
These files are used to build a precompiled header (PCH) file
named wmpa.pch and a precompiled types file named StdAfx.obj.
Resource.h
This is the standard header file, which defines new resource IDs.
Microsoft Visual C++ reads and updates this file.
/////////////////////////////////////////////////////////////////////////////
Other notes:
AppWizard uses "TODO:" to indicate parts of the source code you
should add to or customize.
/////////////////////////////////////////////////////////////////////////////

8
plugins/wmpa/StdAfx.cpp
View File

@ -1,8 +0,0 @@
// stdafx.cpp : source file that includes just the standard includes
// wmpa.pch will be the pre-compiled header
// stdafx.obj will contain the pre-compiled type information
#include "stdafx.h"

62
plugins/wmpa/StdAfx.h
View File

@ -1,62 +0,0 @@
// stdafx.h : include file for standard system include files,
// or project specific include files that are used frequently, but
// are changed infrequently
//
#if !defined(AFX_STDAFX_H__33D7BD1A_A9B6_4BDE_B867_5278529B95B2__INCLUDED_)
#define AFX_STDAFX_H__33D7BD1A_A9B6_4BDE_B867_5278529B95B2__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#define VC_EXTRALEAN // Exclude rarely-used stuff from Windows headers
#include <afxwin.h> // MFC core and standard components
#include <afxext.h> // MFC extensions
#ifndef _AFX_NO_OLE_SUPPORT
#include <afxole.h> // MFC OLE classes
#include <afxodlgs.h> // MFC OLE dialog classes
#include <afxdisp.h> // MFC Automation classes
#endif // _AFX_NO_OLE_SUPPORT
#ifndef _AFX_NO_DB_SUPPORT
#include <afxdb.h> // MFC ODBC database classes
#endif // _AFX_NO_DB_SUPPORT
#ifndef _AFX_NO_DAO_SUPPORT
#include <afxdao.h> // MFC DAO database classes
#endif // _AFX_NO_DAO_SUPPORT
#include <afxdtctl.h> // MFC support for Internet Explorer 4 Common Controls
#ifndef _AFX_NO_AFXCMN_SUPPORT
#include <afxcmn.h> // MFC support for Windows Common Controls
#endif // _AFX_NO_AFXCMN_SUPPORT
/******************************************************************
* Includes
******************************************************************/
#include "wmpcdrom.h"
#include "wmpcdromcollection.h"
#include "wmpclosedcaption.h"
#include "wmpcontrols.h"
#include "wmpdvd.h"
#include "wmperror.h"
#include "wmperroritem.h"
#include "wmpmedia.h"
#include "wmpmediacollection.h"
#include "wmpnetwork.h"
#include "wmpplayer4.h"
#include "wmpplayerapplication.h"
#include "wmpplaylist.h"
#include "wmpplaylistarray.h"
#include "wmpplaylistcollection.h"
#include "wmpsettings.h"
#include "wmpstringcollection.h"
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_STDAFX_H__33D7BD1A_A9B6_4BDE_B867_5278529B95B2__INCLUDED_)

590
plugins/wmpa/hexchat-plugin.cpp
View File

@ -1,590 +0,0 @@
/******************************************************************
* $Id$
*
* $Log$
*
* Copyright © 2005 David Cullen, All rights reserved
*
******************************************************************/
#include "stdafx.h"
#include "hexchat-plugin.h"
#include <windows.h>
#include <tchar.h>
#include "wmpa.h"
#include "WMPADialog.h"
#define XMMS_SESSION 0
/******************************************************************
* Globalss
******************************************************************/
hexchat_plugin *ph = NULL;
CWMPPlayer4 *wmp;
static const char subKey[] = "Software\\FlowerSoft\\WMPA";
/******************************************************************
* hexchat_plugin_init
******************************************************************/
int hexchat_plugin_init(hexchat_plugin *plugin_handle,
char **plugin_name,
char **plugin_desc,
char **plugin_version,
char *arg)
{
BOOL success;
ph = plugin_handle;
*plugin_name = "WMPA";
*plugin_desc = "Announce the current song from Windows Media Player.";
*plugin_version = VER_STRING;
// Show the song browser
success = StartWindowsMediaPlayer();
if (!success) {
hexchat_printf(ph, "WMPA: Failed to show the song browser.");
hexchat_printf(ph, "WMPA: Could not load plug-in version %s.", VER_STRING);
return(E_FAIL);
}
// Get a pointer to the Windows Media Player control
wmp = GetWindowsMediaPlayer();
if (wmp == NULL) {
hexchat_printf(ph, "WMPA: Failed to get a pointer to the Windows Media Player interface.");
hexchat_printf(ph, "WMPA: Could not load plug-in version %s.", VER_STRING);
return(E_POINTER);
}
// Restore the settings (need wmp first)
success = wmpaRestoreSettings();
if (!success) {
hexchat_printf(ph, "WMPA: Failed to restore the settings.");
}
hexchat_hook_command(ph, "auto", HEXCHAT_PRI_NORM, wmpaAuto, 0, 0);
hexchat_hook_command(ph, "curr", HEXCHAT_PRI_NORM, wmpaCurr, 0, 0);
hexchat_hook_command(ph, "find", HEXCHAT_PRI_NORM, wmpaFind, 0, 0);
hexchat_hook_command(ph, "slist", HEXCHAT_PRI_NORM, wmpaList, 0, 0);
hexchat_hook_command(ph, "next", HEXCHAT_PRI_NORM, wmpaNext, 0, 0);
hexchat_hook_command(ph, "play", HEXCHAT_PRI_NORM, wmpaPlay, 0, 0);
hexchat_hook_command(ph, "pause", HEXCHAT_PRI_NORM, wmpaPause, 0, 0);
hexchat_hook_command(ph, "prev", HEXCHAT_PRI_NORM, wmpaPrev, 0, 0);
hexchat_hook_command(ph, "song", HEXCHAT_PRI_NORM, wmpaSong, 0, 0);
hexchat_hook_command(ph, "stop", HEXCHAT_PRI_NORM, wmpaStop, 0, 0);
hexchat_hook_command(ph, "volume", HEXCHAT_PRI_NORM, wmpaVolume, 0, 0);
hexchat_hook_command(ph, "wmpahelp", HEXCHAT_PRI_NORM, wmpaHelp, 0, 0);
hexchat_printf(ph, "WMPA %s successfully loaded.", VER_STRING);
wmpaCommands();
hexchat_printf(ph, "WMPA: e-mail me if you find any bugs: dcullen@intergate.com");
return 1;
}
/******************************************************************
* hexchat_plugin_deinit
******************************************************************/
int hexchat_plugin_deinit(void)
{
BOOL success;
hexchat_printf(ph, "WMPA %s is unloading.", VER_STRING);
// Save the settings
success = wmpaSaveSettings();
if (!success) {
hexchat_printf(ph, "WMPA: Failed to save the settings.");
}
wmp = NULL;
BOOL result = StopWindowsMediaPlayer();
if (!result) {
hexchat_printf(ph, "WMPA could not shut down Windows Media Player.");
}
hexchat_printf(ph, "WMPA %s has unloaded.", VER_STRING);
return 1;
}
/******************************************************************
* hexchat_plugin_get_info
******************************************************************/
void hexchat_plugin_get_info(char **name, char **desc, char **version, void **reserved)
{
*name = "WMPA";
*desc = "Announce the current song from Windows Media Player.";
*version = VER_STRING;
if (reserved) *reserved = NULL;
}
/******************************************************************
* wmpaCommands
******************************************************************/
void wmpaCommands(void)
{
hexchat_printf(ph, "WMPA: /auto [on/off] : Turn on/off auto announce of the current song or display the current setting");
hexchat_printf(ph, "WMPA: /curr : Tell what song is currently playing");
hexchat_printf(ph, "WMPA: /find [word] : Find songs with \"word\" in their title, create a new playlist, and play it");
hexchat_printf(ph, "WMPA: /slist [word] : List songs with \"word\" in their title");
hexchat_printf(ph, "WMPA: /next : Play the next song");
hexchat_printf(ph, "WMPA: /play : Play the current song");
hexchat_printf(ph, "WMPA: /pause : Pause the current song");
hexchat_printf(ph, "WMPA: /prev : Play the previous song");
hexchat_printf(ph, "WMPA: /song : Announce the current song from Windows Media Player in HexChat");
hexchat_printf(ph, "WMPA: /stop : Stop the current song");
hexchat_printf(ph, "WMPA: /volume [volume] : Set the volume (0 to 100) or display the current volume");
hexchat_printf(ph, "WMPA: /wmpahelp : Display this help.");
}
/******************************************************************
* wmpaAuto
******************************************************************/
int wmpaAuto(char *word[], char *word_eol[], void *user_data)
{
CWMPADialog *pDialog;
char *state;
pDialog = GetWMPADialog();
if (pDialog == NULL) return(HEXCHAT_EAT_ALL);
if (CString(word[2]).IsEmpty()) {
if (pDialog->autoAnnounce) {
state = "on";
}
else {
state = "off";
}
}
else {
state = word[2];
if (CString(state) == "on") {
pDialog->autoAnnounce = TRUE;
}
if (CString(state) == "off") {
pDialog->autoAnnounce = FALSE;
}
wmpaSaveSettings();
}
hexchat_printf(ph, "WMPA: auto is %s", state);
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaCurr
******************************************************************/
int wmpaCurr(char *word[], char *word_eol[], void *user_data)
{
hexchat_printf(ph, "WMPA: Playing %s", (LPCTSTR) wmpaGetSongTitle());
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaFind
******************************************************************/
int wmpaFind(char *word[], char *word_eol[], void *user_data)
{
long index;
long count;
long found;
if (wmp != NULL) {
CWMPMediaCollection mc = wmp->GetMediaCollection();
CWMPPlaylist all = mc.getAll();
CWMPPlaylistCollection pc = wmp->GetPlaylistCollection();
CWMPPlaylistArray pa = pc.getAll();
CWMPPlaylist playlist;
CWMPMedia media;
for (index = 0; index < pc.getAll().GetCount(); index++) {
if (pc.getAll().Item(index).GetName() == CString(word_eol[2])) {
playlist = pc.getAll().Item(index);
pc.remove(playlist);
}
}
playlist = pc.newPlaylist(word_eol[2]);
count = all.GetCount();
found = 0;
for (index = 0; index < count; index++) {
media = all.GetItem(index);
CString artist = media.getItemInfo("Artist");
CString title = media.getItemInfo("Title");
CString album = media.getItemInfo("Album");
if ( (artist.Find(word_eol[2]) != -1) ||
(title.Find(word_eol[2]) != -1) ||
(album.Find(word_eol[2]) != -1) ) {
playlist.appendItem(media);
found++;
}
}
if (found > 0) {
hexchat_printf(ph, "WMPA: Found %d songs with \"%s\" in them", found, word_eol[2]);
wmp->SetCurrentPlaylist(playlist);
wmp->GetControls().play();
hexchat_printf(ph, "WMPA: Playing %s", (LPCTSTR) wmpaGetSongTitle());
CWMPADialog *dialog = GetWMPADialog();
if (dialog != NULL) {
dialog->UpdateSongList();
dialog->SelectCurrentSong();
dialog->UpdatePlayLists();
}
}
else {
hexchat_printf(ph, "WMPA: Could not find %s", word_eol[2]);
}
}
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaList
******************************************************************/
int wmpaList(char *word[], char *word_eol[], void *user_data)
{
long index;
long count;
long found;
if (wmp != NULL) {
hexchat_printf(ph, "WMPA: Listing songs with \"%s\" in them", word_eol[2]);
CWMPMediaCollection mc = wmp->GetMediaCollection();
CWMPPlaylist all = mc.getAll();
CWMPMedia media;
count = all.GetCount();
found = 0;
for (index = 0; index < count; index++) {
media = all.GetItem(index);
CString artist = media.getItemInfo("Artist");
CString title = media.getItemInfo("Title");
CString album = media.getItemInfo("Album");
if ( (artist.Find(word_eol[2]) != -1) ||
(title.Find(word_eol[2]) != -1) ||
(album.Find(word_eol[2]) != -1) ) {
hexchat_printf(ph, "WMPA: Found \"%s - %s (%s)\"", artist, title, album);
found++;
}
}
if (found > 0) {
if (found == 1)
hexchat_printf(ph, "WMPA: Found %d song with \"%s\" in it", found, word_eol[2]);
else
hexchat_printf(ph, "WMPA: Found %d songs with \"%s\" in them", found, word_eol[2]);
}
else {
hexchat_printf(ph, "WMPA: Could not find any songs with \"%s\" in them", word_eol[2]);
}
}
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaNext
******************************************************************/
int wmpaNext(char *word[], char *word_eol[], void *user_data)
{
if (wmp != NULL) {
wmp->GetControls().next();
hexchat_printf(ph, "WMPA: Playing %s", (LPCTSTR) wmpaGetSongTitle());
}
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaPlay
******************************************************************/
int wmpaPlay(char *word[], char *word_eol[], void *user_data)
{
if (wmp != NULL) {
wmp->GetControls().play();
hexchat_printf(ph, "WMPA: Playing %s", (LPCTSTR) wmpaGetSongTitle());
}
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaPause
******************************************************************/
int wmpaPause(char *word[], char *word_eol[], void *user_data)
{
if (wmp != NULL) {
wmp->GetControls().pause();
hexchat_printf(ph, "WMPA: Pausing %s", (LPCTSTR) wmpaGetSongTitle());
}
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaPrev
******************************************************************/
int wmpaPrev(char *word[], char *word_eol[], void *user_data)
{
if (wmp != NULL) {
wmp->GetControls().previous();
hexchat_printf(ph, "WMPA: Playing %s", (LPCTSTR) wmpaGetSongTitle());
}
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaSong
******************************************************************/
int wmpaSong(char *word[], char *word_eol[], void *user_data)
{
CString songTitle = wmpaGetSongTitle();
hexchat_commandf(ph, "me is playing %s", (LPCTSTR) songTitle);
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaStop
******************************************************************/
int wmpaStop(char *word[], char *word_eol[], void *user_data)
{
if (wmp != NULL) {
wmp->GetControls().stop();
hexchat_printf(ph, "WMPA: Stopping %s", (LPCTSTR) wmpaGetSongTitle());
}
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaHelp
******************************************************************/
int wmpaHelp(char *word[], char *word_eol[], void *user_data)
{
hexchat_printf(ph, "\n");
hexchat_printf(ph, "WMPA %s Help", VER_STRING);
wmpaCommands();
hexchat_printf(ph, "\n");
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaVolume
******************************************************************/
int wmpaVolume(char *word[], char *word_eol[], void *user_data)
{
char *endPtr;
long volume;
if (CString(word[2]).IsEmpty()) {
volume = wmp->GetSettings().GetVolume();
}
else {
volume = strtol(word[2], &endPtr, 10);
if ((wmp != NULL) && (volume >= 0) && (volume <= 100)) {
wmp->GetSettings().SetVolume(volume);
wmpaSaveSettings();
}
}
hexchat_printf(ph, "WMPA: volume is %d", volume);
return(HEXCHAT_EAT_ALL);
}
/******************************************************************
* wmpaRestoreSettings
******************************************************************/
BOOL wmpaRestoreSettings(void)
{
CWMPADialog *pDialog;
DWORD type;
int volume;
BOOL autoAnnounce;
DWORD size;
BOOL result;
if (wmp == NULL) return(FALSE);
volume = 50;
result = GetSetting("Volume", &type, (LPBYTE) &volume, &size);
wmp->GetSettings().SetVolume(volume);
autoAnnounce = FALSE;
pDialog = GetWMPADialog();
if (pDialog != NULL) {
result = result && GetSetting("Auto", &type, (LPBYTE) &autoAnnounce, &size);
pDialog->autoAnnounce = autoAnnounce;
}
else {
result = FALSE;
}
return(result);
}
/******************************************************************
* wmpaSaveSettings
******************************************************************/
BOOL wmpaSaveSettings(void)
{
CWMPADialog *pDialog;
int volume;
BOOL autoAnnounce;
BOOL result;
if (wmp == NULL) return(FALSE);
volume = wmp->GetSettings().GetVolume();
result = SaveSetting("Volume", REG_DWORD, (CONST BYTE *) &volume, sizeof(volume));
pDialog = GetWMPADialog();
if (pDialog != NULL) {
autoAnnounce = pDialog->autoAnnounce;
result = result && SaveSetting("Auto", REG_DWORD, (CONST BYTE *) &autoAnnounce, sizeof(autoAnnounce));
}
else {
result = FALSE;
}
return(result);
}
/******************************************************************
* wmpaGetSongTitle
******************************************************************/
CString wmpaGetSongTitle(void)
{
char buffer[32];
if (wmp == NULL) return(CString());
CWMPMedia media = wmp->GetCurrentMedia();
if (media == NULL) {
hexchat_printf(ph, "WMPA: Could not get current media");
return(CString ("%d", HEXCHAT_EAT_ALL));
}
CString artist = media.getItemInfo("Artist");
CString title = media.getItemInfo("Title");
CString album = media.getItemInfo("Album");
CString bitrate = media.getItemInfo("Bitrate");
CString duration = media.GetDurationString();
long krate = strtoul((LPCTSTR) bitrate, NULL, 10) / 1000;
_ultoa(krate, buffer, 10);
bitrate = CString(buffer);
// Creatte the song title
CString songTitle("");
songTitle += artist;
if (songTitle.IsEmpty()) songTitle += "Various";
songTitle += " - ";
songTitle += title;
songTitle += " (";
songTitle += album;
songTitle += ") [";
songTitle += duration;
songTitle += "/";
songTitle += bitrate;
songTitle += "Kbps]";
return(songTitle);
}
/******************************************************************
* SaveSetting
******************************************************************/
BOOL SaveSetting(LPCTSTR name, DWORD type, CONST BYTE *value, DWORD size)
{
HKEY hKey;
DWORD disposition;
LONG result;
if (wmp == NULL) return(FALSE);
if (name == NULL) return(FALSE);
result = RegOpenKeyEx(HKEY_CURRENT_USER,
subKey,
0,
KEY_WRITE,
&hKey);
if (result != ERROR_SUCCESS) {
result = RegCreateKeyEx(HKEY_CURRENT_USER,
subKey,
0,
NULL,
REG_OPTION_NON_VOLATILE,
KEY_WRITE,
NULL,
&hKey,
&disposition);
if (result != ERROR_SUCCESS) return(FALSE);
}
result = RegSetValueEx(hKey,
name,
0,
type,
value,
size);
if (result == ERROR_SUCCESS) {
RegCloseKey(hKey);
return(TRUE);
}
RegCloseKey(hKey);
return(FALSE);
}
/******************************************************************
* GetSetting
******************************************************************/
BOOL GetSetting(LPCTSTR name, DWORD *type, LPBYTE value, DWORD *size)
{
HKEY hKey;
LONG result;
if (wmp == NULL) return(FALSE);
if (type == NULL) return(FALSE);
if (value == NULL) return(FALSE);
if (size == NULL) return(FALSE);
result = RegOpenKeyEx(HKEY_CURRENT_USER,
subKey,
0,
KEY_READ,
&hKey);
if (result != ERROR_SUCCESS) return(FALSE);
result = RegQueryValueEx(hKey,
name,
0,
type,
value,
size);
RegCloseKey(hKey);
if (result == ERROR_SUCCESS) {
return(TRUE);
}
RegCloseKey(hKey);
return(FALSE);
}

361
plugins/wmpa/hexchat-plugin.h
View File

@ -1,361 +0,0 @@
/* You can distribute this header with your plugins for easy compilation */
#ifndef HEXCHAT_PLUGIN_H
#define HEXCHAT_PLUGIN_H
#define VER_STRING _T("1.0.2 (BETA)")
#include "stdafx.h"
#include <windows.h>
#include <time.h>
#include <tchar.h>
#define HEXCHAT_PRI_HIGHEST 127
#define HEXCHAT_PRI_HIGH 64
#define HEXCHAT_PRI_NORM 0
#define HEXCHAT_PRI_LOW (-64)
#define HEXCHAT_PRI_LOWEST (-128)
#define HEXCHAT_FD_READ 1
#define HEXCHAT_FD_WRITE 2
#define HEXCHAT_FD_EXCEPTION 4
#define HEXCHAT_FD_NOTSOCKET 8
#define HEXCHAT_EAT_NONE 0 /* pass it on through! */
#define HEXCHAT_EAT_HEXCHAT 1 /* don't let HexChat see this event */
#define HEXCHAT_EAT_PLUGIN 2 /* don't let other plugins see this event */
#define HEXCHAT_EAT_ALL (HEXCHAT_EAT_HEXCHAT|HEXCHAT_EAT_PLUGIN) /* don't let anything see this event */
#ifdef __cplusplus
extern "C" {
#endif
typedef struct _hexchat_plugin hexchat_plugin;
typedef struct _hexchat_list hexchat_list;
typedef struct _hexchat_hook hexchat_hook;
#ifndef PLUGIN_C
typedef struct _hexchat_context hexchat_context;
#endif
#ifndef PLUGIN_C
struct _hexchat_plugin {
/* these are only used on win32 */
hexchat_hook *(*hexchat_hook_command) (hexchat_plugin *ph,
const char *name,
int pri,
int (*callback) (char *word[], char *word_eol[], void *user_data),
const char *help_text,
void *userdata);
hexchat_hook *(*hexchat_hook_server) (hexchat_plugin *ph,
const char *name,
int pri,
int (*callback) (char *word[], char *word_eol[], void *user_data),
void *userdata);
hexchat_hook *(*hexchat_hook_print) (hexchat_plugin *ph,
const char *name,
int pri,
int (*callback) (char *word[], void *user_data),
void *userdata);
hexchat_hook *(*hexchat_hook_timer) (hexchat_plugin *ph,
int timeout,
int (*callback) (void *user_data),
void *userdata);
hexchat_hook *(*hexchat_hook_fd) (hexchat_plugin *ph,
int fd,
int flags,
int (*callback) (int fd, int flags, void *user_data),
void *userdata);
void *(*hexchat_unhook) (hexchat_plugin *ph,
hexchat_hook *hook);
void (*hexchat_print) (hexchat_plugin *ph,
const char *text);
void (*hexchat_printf) (hexchat_plugin *ph,
const char *format, ...);
void (*hexchat_command) (hexchat_plugin *ph,
const char *command);
void (*hexchat_commandf) (hexchat_plugin *ph,
const char *format, ...);
int (*hexchat_nickcmp) (hexchat_plugin *ph,
const char *s1,
const char *s2);
int (*hexchat_set_context) (hexchat_plugin *ph,
hexchat_context *ctx);
hexchat_context *(*hexchat_find_context) (hexchat_plugin *ph,
const char *servname,
const char *channel);
hexchat_context *(*hexchat_get_context) (hexchat_plugin *ph);
const char *(*hexchat_get_info) (hexchat_plugin *ph,
const char *id);
int (*hexchat_get_prefs) (hexchat_plugin *ph,
const char *name,
const char **string,
int *integer);
hexchat_list * (*hexchat_list_get) (hexchat_plugin *ph,
const char *name);
void (*hexchat_list_free) (hexchat_plugin *ph,
hexchat_list *xlist);
const char * const * (*hexchat_list_fields) (hexchat_plugin *ph,
const char *name);
int (*hexchat_list_next) (hexchat_plugin *ph,
hexchat_list *xlist);
const char * (*hexchat_list_str) (hexchat_plugin *ph,
hexchat_list *xlist,
const char *name);
int (*hexchat_list_int) (hexchat_plugin *ph,
hexchat_list *xlist,
const char *name);
void * (*hexchat_plugingui_add) (hexchat_plugin *ph,
const char *filename,
const char *name,
const char *desc,
const char *version,
char *reserved);
void (*hexchat_plugingui_remove) (hexchat_plugin *ph,
void *handle);
int (*hexchat_emit_print) (hexchat_plugin *ph,
const char *event_name, ...);
int (*hexchat_read_fd) (hexchat_plugin *ph,
void *src,
char *buf,
int *len);
time_t (*hexchat_list_time) (hexchat_plugin *ph,
hexchat_list *xlist,
const char *name);
char *(*hexchat_gettext) (hexchat_plugin *ph,
const char *msgid);
void (*hexchat_send_modes) (hexchat_plugin *ph,
const char **targets,
int ntargets,
int modes_per_line,
char sign,
char mode);
char *(*hexchat_strip) (hexchat_plugin *ph,
const char *str,
int len,
int flags);
void (*hexchat_free) (hexchat_plugin *ph,
void *ptr);
};
#endif
hexchat_hook *
hexchat_hook_command (hexchat_plugin *ph,
const char *name,
int pri,
int (*callback) (char *word[], char *word_eol[], void *user_data),
const char *help_text,
void *userdata);
hexchat_hook *
hexchat_hook_server (hexchat_plugin *ph,
const char *name,
int pri,
int (*callback) (char *word[], char *word_eol[], void *user_data),
void *userdata);
hexchat_hook *
hexchat_hook_print (hexchat_plugin *ph,
const char *name,
int pri,
int (*callback) (char *word[], void *user_data),
void *userdata);
hexchat_hook *
hexchat_hook_timer (hexchat_plugin *ph,
int timeout,
int (*callback) (void *user_data),
void *userdata);
hexchat_hook *
hexchat_hook_fd (hexchat_plugin *ph,
int fd,
int flags,
int (*callback) (int fd, int flags, void *user_data),
void *userdata);
void *
hexchat_unhook (hexchat_plugin *ph,
hexchat_hook *hook);
void
hexchat_print (hexchat_plugin *ph,
const char *text);
void
hexchat_printf (hexchat_plugin *ph,
const char *format, ...);
void
hexchat_command (hexchat_plugin *ph,
const char *command);
void
hexchat_commandf (hexchat_plugin *ph,
const char *format, ...);
int
hexchat_nickcmp (hexchat_plugin *ph,
const char *s1,
const char *s2);
int
hexchat_set_context (hexchat_plugin *ph,
hexchat_context *ctx);
hexchat_context *
hexchat_find_context (hexchat_plugin *ph,
const char *servname,
const char *channel);
hexchat_context *
hexchat_get_context (hexchat_plugin *ph);
const char *
hexchat_get_info (hexchat_plugin *ph,
const char *id);
int
hexchat_get_prefs (hexchat_plugin *ph,
const char *name,
const char **string,
int *integer);
hexchat_list *
hexchat_list_get (hexchat_plugin *ph,
const char *name);
void
hexchat_list_free (hexchat_plugin *ph,
hexchat_list *xlist);
const char * const *
hexchat_list_fields (hexchat_plugin *ph,
const char *name);
int
hexchat_list_next (hexchat_plugin *ph,
hexchat_list *xlist);
const char *
hexchat_list_str (hexchat_plugin *ph,
hexchat_list *xlist,
const char *name);
int
hexchat_list_int (hexchat_plugin *ph,
hexchat_list *xlist,
const char *name);
time_t
hexchat_list_time (hexchat_plugin *ph,
hexchat_list *xlist,
const char *name);
void *
hexchat_plugingui_add (hexchat_plugin *ph,
const char *filename,
const char *name,
const char *desc,
const char *version,
char *reserved);
void
hexchat_plugingui_remove (hexchat_plugin *ph,
void *handle);
int
hexchat_emit_print (hexchat_plugin *ph,
const char *event_name, ...);
char *
hexchat_gettext (hexchat_plugin *ph,
const char *msgid);
void
hexchat_send_modes (hexchat_plugin *ph,
const char **targets,
int ntargets,
int modes_per_line,
char sign,
char mode);
char *
hexchat_strip (hexchat_plugin *ph,
const char *str,
int len,
int flags);
void
hexchat_free (hexchat_plugin *ph,
void *ptr);
#if !defined(PLUGIN_C) && defined(WIN32)
#ifndef HEXCHAT_PLUGIN_HANDLE
#define HEXCHAT_PLUGIN_HANDLE (ph)
#endif
#define hexchat_hook_command ((HEXCHAT_PLUGIN_HANDLE)->hexchat_hook_command)
#define hexchat_hook_server ((HEXCHAT_PLUGIN_HANDLE)->hexchat_hook_server)
#define hexchat_hook_print ((HEXCHAT_PLUGIN_HANDLE)->hexchat_hook_print)
#define hexchat_hook_timer ((HEXCHAT_PLUGIN_HANDLE)->hexchat_hook_timer)
#define hexchat_hook_fd ((HEXCHAT_PLUGIN_HANDLE)->hexchat_hook_fd)
#define hexchat_unhook ((HEXCHAT_PLUGIN_HANDLE)->hexchat_unhook)
#define hexchat_print ((HEXCHAT_PLUGIN_HANDLE)->hexchat_print)
#define hexchat_printf ((HEXCHAT_PLUGIN_HANDLE)->hexchat_printf)
#define hexchat_command ((HEXCHAT_PLUGIN_HANDLE)->hexchat_command)
#define hexchat_commandf ((HEXCHAT_PLUGIN_HANDLE)->hexchat_commandf)
#define hexchat_nickcmp ((HEXCHAT_PLUGIN_HANDLE)->hexchat_nickcmp)
#define hexchat_set_context ((HEXCHAT_PLUGIN_HANDLE)->hexchat_set_context)
#define hexchat_find_context ((HEXCHAT_PLUGIN_HANDLE)->hexchat_find_context)
#define hexchat_get_context ((HEXCHAT_PLUGIN_HANDLE)->hexchat_get_context)
#define hexchat_get_info ((HEXCHAT_PLUGIN_HANDLE)->hexchat_get_info)
#define hexchat_get_prefs ((HEXCHAT_PLUGIN_HANDLE)->hexchat_get_prefs)
#define hexchat_list_get ((HEXCHAT_PLUGIN_HANDLE)->hexchat_list_get)
#define hexchat_list_free ((HEXCHAT_PLUGIN_HANDLE)->hexchat_list_free)
#define hexchat_list_fields ((HEXCHAT_PLUGIN_HANDLE)->hexchat_list_fields)
#define hexchat_list_str ((HEXCHAT_PLUGIN_HANDLE)->hexchat_list_str)
#define hexchat_list_int ((HEXCHAT_PLUGIN_HANDLE)->hexchat_list_int)
#define hexchat_list_time ((HEXCHAT_PLUGIN_HANDLE)->hexchat_list_time)
#define hexchat_list_next ((HEXCHAT_PLUGIN_HANDLE)->hexchat_list_next)
#define hexchat_plugingui_add ((HEXCHAT_PLUGIN_HANDLE)->hexchat_plugingui_add)
#define hexchat_plugingui_remove ((HEXCHAT_PLUGIN_HANDLE)->hexchat_plugingui_remove)
#define hexchat_emit_print ((HEXCHAT_PLUGIN_HANDLE)->hexchat_emit_print)
#define hexchat_gettext ((HEXCHAT_PLUGIN_HANDLE)->hexchat_gettext)
#define hexchat_send_modes ((HEXCHAT_PLUGIN_HANDLE)->hexchat_send_modes)
#define hexchat_strip ((HEXCHAT_PLUGIN_HANDLE)->hexchat_strip)
#define hexchat_free ((HEXCHAT_PLUGIN_HANDLE)->hexchat_free)
#endif
#ifdef __cplusplus
}
#endif
/******************************************************************
* Globals
******************************************************************/
extern hexchat_plugin *ph;
/******************************************************************
* Prototypes
******************************************************************/
void wmpaCommands(void);
int wmpaAuto(char *word[], char *word_eol[], void *user_data);
int wmpaCurr(char *word[], char *word_eol[], void *user_data);
int wmpaFind(char *word[], char *word_eol[], void *user_data);
int wmpaList(char *word[], char *word_eol[], void *user_data);
int wmpaNext(char *word[], char *word_eol[], void *user_data);
int wmpaPlay(char *word[], char *word_eol[], void *user_data);
int wmpaPause(char *word[], char *word_eol[], void *user_data);
int wmpaPrev(char *word[], char *word_eol[], void *user_data);
int wmpaSong(char *word[], char *word_eol[], void *user_data);
int wmpaStop(char *word[], char *word_eol[], void *user_data);
int wmpaVolume(char *word[], char *word_eol[], void *user_data);
int wmpaHelp(char *word[], char *word_eol[], void *user_data);
BOOL wmpaRestoreSettings(void);
BOOL wmpaSaveSettings(void);
CString wmpaGetSongTitle(void);
BOOL SaveSetting(LPCTSTR name, DWORD type, CONST BYTE *value, DWORD size);
BOOL GetSetting(LPCTSTR name, DWORD *type, LPBYTE value, DWORD *size);
#endif /* HEXCHAT_PLUGIN_H */

13
plugins/wmpa/res/wmpa.rc2
View File

@ -1,13 +0,0 @@
//
// WMPA.RC2 - resources Microsoft Visual C++ does not edit directly
//
#ifdef APSTUDIO_INVOKED
#error this file is not editable by Microsoft Visual C++
#endif //APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
// Add manually edited resources here...
/////////////////////////////////////////////////////////////////////////////

22
plugins/wmpa/resource.h
View File

@ -1,22 +0,0 @@
//{{NO_DEPENDENCIES}}
// Microsoft Developer Studio generated include file.
// Used by wmpa.rc
//
#define IDD_WMPADIALOG 2000
#define IDC_PLAYLIST 2001
#define IDC_STATIC1 2002
#define IDC_WMP 2005
#define IDI_XCHAT 2005
#define IDC_SONGLIST 2006
#define IDC_STATIC2 2007
// Next default values for new objects
//
#ifdef APSTUDIO_INVOKED
#ifndef APSTUDIO_READONLY_SYMBOLS
#define _APS_NEXT_RESOURCE_VALUE 2006
#define _APS_NEXT_COMMAND_VALUE 32771
#define _APS_NEXT_CONTROL_VALUE 2008
#define _APS_NEXT_SYMED_VALUE 2000
#endif
#endif

212
plugins/wmpa/wmpa.cpp
View File

@ -1,212 +0,0 @@
/******************************************************************
* $Id$
*
* $Log$
*
* Copyright © 2005 David Cullen, All rights reserved
*
******************************************************************/
#include "stdafx.h"
#include "wmpa.h"
#include "WMPADialog.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
//
// Note!
//
// If this DLL is dynamically linked against the MFC
// DLLs, any functions exported from this DLL which
// call into MFC must have the AFX_MANAGE_STATE macro
// added at the very beginning of the function.
//
// For example:
//
// extern "C" BOOL PASCAL EXPORT ExportedFunction()
// {
// AFX_MANAGE_STATE(AfxGetStaticModuleState());
// // normal function body here
// }
//
// It is very important that this macro appear in each
// function, prior to any calls into MFC. This means that
// it must appear as the first statement within the
// function, even before any object variable declarations
// as their constructors may generate calls into the MFC
// DLL.
//
// Please see MFC Technical Notes 33 and 58 for additional
// details.
//
/////////////////////////////////////////////////////////////////////////////
// CWmpaApp
BEGIN_MESSAGE_MAP(CWmpaApp, CWinApp)
//{{AFX_MSG_MAP(CWmpaApp)
// NOTE - the ClassWizard will add and remove mapping macros here.
// DO NOT EDIT what you see in these blocks of generated code!
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CWmpaApp construction
CWmpaApp::CWmpaApp()
{
// TODO: add construction code here,
// Place all significant initialization in InitInstance
m_pDialog = NULL;
}
/////////////////////////////////////////////////////////////////////////////
// The one and only CWmpaApp object
CWmpaApp theApp;
/////////////////////////////////////////////////////////////////////////////
// CWmpaApp initialization
BOOL CWmpaApp::InitInstance()
{
// Register all OLE server (factories) as running. This enables the
// OLE libraries to create objects from other applications.
COleObjectFactory::RegisterAll();
// WARNING: This function enables the ActiveX control container
// Without this function you will not be able to load the WMP
// In fact you will get the following error:
// >>> If this dialog has OLE controls:
// >>> AfxEnableControlContainer has not been called yet.
// >>> You should call it in your app's InitInstance function.
AfxEnableControlContainer();
// WARNING: This function initializes the COM library for use
// Without this function you will not be able to load the WMP
// In fact you will get the following error:
// CoCreateInstance of OLE control {6BF52A52-394A-11D3-B153-00C04F79FAA6} failed.
// >>> Result code: 0x800401f0
// >>> Is the control is properly registered?
// The Error Lookup tool will tell you result code 0x800401F0 means
// CoInitialize has not been called.
CoInitialize(NULL);
return TRUE;
}
/******************************************************************
* ShowWMPA
******************************************************************/
BOOL CWmpaApp::ShowWMPA(void)
{
HRESULT result = FALSE;
BOOL created;
// WARNING: The following two funcions make sure we look for
// our resources in our DLL not in the calling EXE
// Without these functions you will not be able to load the
// Windows Media Player
HMODULE hModule = GetModuleHandle("WMPA.DLL");
AfxSetResourceHandle((HINSTANCE) hModule);
if (m_pDialog == NULL) m_pDialog = new CWMPADialog;
created = m_pDialog->Create(IDD_WMPADIALOG, m_pDialog);
if (!created) return(E_FAIL);
m_pDialog->m_hIcon = LoadIcon(IDI_XCHAT);
m_pDialog->SetIcon(m_pDialog->m_hIcon, TRUE);
result = m_pDialog->ShowWindow(SW_SHOWNORMAL);
return(created);
}
/////////////////////////////////////////////////////////////////////////////
// Special entry points required for inproc servers
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
return AfxDllGetClassObject(rclsid, riid, ppv);
}
STDAPI DllCanUnloadNow(void)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
return AfxDllCanUnloadNow();
}
// by exporting DllRegisterServer, you can use regsvr.exe
STDAPI DllRegisterServer(void)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
COleObjectFactory::UpdateRegistryAll();
return(S_OK);
}
/******************************************************************
* DestroyWMPA
******************************************************************/
BOOL CWmpaApp::DestroyWMPA(void)
{
if (theApp.m_pDialog == NULL) return(FALSE);
theApp.m_pDialog->m_WMP.GetControls().stop();
theApp.m_pDialog->DeleteTrayIcon();
theApp.m_pDialog->DestroyWindow();
return(TRUE);
}
/******************************************************************
* StartWindowsMediaPlayer
******************************************************************/
BOOL StartWindowsMediaPlayer(void)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
BOOL result = theApp.ShowWMPA();
return(result);
}
/******************************************************************
* StopWindowsMediaPlayer
******************************************************************/
BOOL StopWindowsMediaPlayer(void)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
BOOL result = theApp.DestroyWMPA();
return(result);
}
/******************************************************************
* GetWindowsMediaPlayer
******************************************************************/
CWMPPlayer4 *GetWindowsMediaPlayer(void)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
if (theApp.m_pDialog == NULL) return(NULL);
return(&(theApp.m_pDialog->m_WMP));
}
/******************************************************************
* GetWMPADialog
******************************************************************/
CWMPADialog *GetWMPADialog(void)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
if (theApp.m_pDialog == NULL) return(NULL);
return(theApp.m_pDialog);
}

15
plugins/wmpa/wmpa.def
View File

@ -1,15 +0,0 @@
; wmpa.def : Declares the module parameters for the DLL.
LIBRARY "hcwmpa"
EXPORTS
; Explicit exports can go here
DllCanUnloadNow PRIVATE
DllGetClassObject PRIVATE
DllRegisterServer PRIVATE
hexchat_plugin_init
hexchat_plugin_deinit
hexchat_plugin_get_info
StartWindowsMediaPlayer
GetWindowsMediaPlayer
GetWMPADialog

61
plugins/wmpa/wmpa.h
View File

@ -1,61 +0,0 @@
/******************************************************************
* $Id$
*
* $Log$
*
* Copyright © 2005 David Cullen, All rights reserved
*
******************************************************************/
#if !defined(AFX_WMPA_H__11200FE3_F137_48DD_8020_91CF7BBB283B__INCLUDED_)
#define AFX_WMPA_H__11200FE3_F137_48DD_8020_91CF7BBB283B__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#ifndef __AFXWIN_H__
#error include 'stdafx.h' before including this file for PCH
#endif
#include "resource.h" // main symbols
#include "WMPADialog.h"
/////////////////////////////////////////////////////////////////////////////
// CWmpaApp
// See wmpa.cpp for the implementation of this class
//
class CWmpaApp : public CWinApp
{
public:
CWmpaApp();
BOOL ShowWMPA(void);
BOOL DestroyWMPA(void);
CWMPADialog *m_pDialog;
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CWmpaApp)
public:
virtual BOOL InitInstance();
//}}AFX_VIRTUAL
//{{AFX_MSG(CWmpaApp)
// NOTE - the ClassWizard will add and remove member functions here.
// DO NOT EDIT what you see in these blocks of generated code !
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
BOOL StartWindowsMediaPlayer(void);
BOOL StopWindowsMediaPlayer(void);
CWMPPlayer4 *GetWindowsMediaPlayer(void);
CWMPADialog *GetWMPADialog(void);
/////////////////////////////////////////////////////////////////////////////
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPA_H__11200FE3_F137_48DD_8020_91CF7BBB283B__INCLUDED_)

BIN
plugins/wmpa/wmpa.ico
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 4.2 KiB

44
plugins/wmpa/wmpa.odl
View File

@ -1,44 +0,0 @@
// wmpa.odl : type library source for wmpa.dll
// This file will be processed by the MIDL compiler to produce the
// type library (wmpa.tlb).
[ uuid(2D225385-EFD3-4DD8-9377-A7F244C522D0), version(1.0) ]
library Wmpa
{
importlib("stdole32.tlb");
importlib("stdole2.tlb");
// Primary dispatch interface for CWMPADIALOG
[ uuid(01C1B3AA-C7FC-4023-89A5-C814E1B62B9B) ]
dispinterface IWMPADIALOG
{
properties:
// NOTE - ClassWizard will maintain property information here.
// Use extreme caution when editing this section.
//{{AFX_ODL_PROP(CWMPADIALOG)
//}}AFX_ODL_PROP
methods:
// NOTE - ClassWizard will maintain method information here.
// Use extreme caution when editing this section.
//{{AFX_ODL_METHOD(CWMPADIALOG)
//}}AFX_ODL_METHOD
};
// Class information for CWMPADIALOG
[ uuid(9007B1B4-0006-453D-A799-DB8CBA1AE22A) ]
coclass WMPADIALOG
{
[default] dispinterface IWMPADIALOG;
};
//{{AFX_APPEND_ODL}}
//}}AFX_APPEND_ODL}}
};

207
plugins/wmpa/wmpa.rc
View File

@ -1,207 +0,0 @@
//Microsoft Developer Studio generated resource script.
//
#include "resource.h"
#define APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 2 resource.
//
#include "afxres.h"
/////////////////////////////////////////////////////////////////////////////
#undef APSTUDIO_READONLY_SYMBOLS
/////////////////////////////////////////////////////////////////////////////
// English (U.S.) resources
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
#ifdef _WIN32
LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
#pragma code_page(1252)
#endif //_WIN32
#ifdef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// TEXTINCLUDE
//
1 TEXTINCLUDE DISCARDABLE
BEGIN
"resource.h\0"
END
2 TEXTINCLUDE DISCARDABLE
BEGIN
"#include ""afxres.h""\r\n"
"\0"
END
3 TEXTINCLUDE DISCARDABLE
BEGIN
"#define _AFX_NO_SPLITTER_RESOURCES\r\n"
"#define _AFX_NO_OLE_RESOURCES\r\n"
"#define _AFX_NO_TRACKER_RESOURCES\r\n"
"#define _AFX_NO_PROPERTY_RESOURCES\r\n"
"\r\n"
"#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)\r\n"
"#ifdef _WIN32\r\n"
"LANGUAGE 9, 1\r\n"
"#pragma code_page(1252)\r\n"
"#endif //_WIN32\r\n"
"#include ""res\\wmpa.rc2"" // non-Microsoft Visual C++ edited resources\r\n"
"#include ""afxres.rc"" // Standard components\r\n"
"#endif\r\n"
"\0"
END
#endif // APSTUDIO_INVOKED
#ifndef _MAC
/////////////////////////////////////////////////////////////////////////////
//
// Version
//
VS_VERSION_INFO VERSIONINFO
FILEVERSION 1,0,0,1
PRODUCTVERSION 1,0,0,1
FILEFLAGSMASK 0x3fL
#ifdef _DEBUG
FILEFLAGS 0x1L
#else
FILEFLAGS 0x0L
#endif
FILEOS 0x4L
FILETYPE 0x2L
FILESUBTYPE 0x0L
BEGIN
BLOCK "StringFileInfo"
BEGIN
BLOCK "040904B0"
BEGIN
VALUE "CompanyName", "\0"
VALUE "FileDescription", "wmpa DLL\0"
VALUE "FileVersion", "1, 0, 0, 1\0"
VALUE "InternalName", "wmpa\0"
VALUE "LegalCopyright", "Copyright (C) 2005\0"
VALUE "LegalTrademarks", "\0"
VALUE "OriginalFilename", "wmpa.DLL\0"
VALUE "ProductName", "wmpa Dynamic Link Library\0"
VALUE "ProductVersion", "1, 0, 0, 1\0"
VALUE "OLESelfRegister", "\0"
END
END
BLOCK "VarFileInfo"
BEGIN
VALUE "Translation", 0x409, 1200
END
END
#endif // !_MAC
/////////////////////////////////////////////////////////////////////////////
//
// Dialog
//
IDD_WMPADIALOG DIALOG DISCARDABLE 0, 0, 317, 236
STYLE DS_MODALFRAME | WS_MINIMIZEBOX | WS_POPUP | WS_CAPTION | WS_SYSMENU
CAPTION "Unitialized"
FONT 8, "MS Sans Serif"
BEGIN
LISTBOX IDC_PLAYLIST,165,15,145,145,LBS_NOINTEGRALHEIGHT |
WS_VSCROLL | WS_HSCROLL | WS_TABSTOP
LTEXT "Play Lists (Double-click to play)",IDC_STATIC1,165,5,
145,10
CONTROL "",IDC_WMP,"{6BF52A52-394A-11D3-B153-00C04F79FAA6}",
WS_TABSTOP,5,5,155,155
LISTBOX IDC_SONGLIST,5,175,305,55,LBS_NOINTEGRALHEIGHT |
WS_VSCROLL | WS_TABSTOP
LTEXT "Song List (Double-click to play)",IDC_STATIC2,5,165,305,
10
END
/////////////////////////////////////////////////////////////////////////////
//
// DESIGNINFO
//
#ifdef APSTUDIO_INVOKED
GUIDELINES DESIGNINFO DISCARDABLE
BEGIN
IDD_WMPADIALOG, DIALOG
BEGIN
LEFTMARGIN, 7
RIGHTMARGIN, 310
TOPMARGIN, 7
BOTTOMMARGIN, 229
END
END
#endif // APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Dialog Info
//
IDD_WMPADIALOG DLGINIT
BEGIN
IDC_WMP, 0x376, 166, 0
0x0000, 0x0000, 0x0300, 0x0000, 0x0008, 0x0000, 0x0000, 0x0005, 0x0000,
0x0000, 0x0000, 0x3ff0, 0x0003, 0x0000, 0x0000, 0x0005, 0x0000, 0x0000,
0x0000, 0x0000, 0x0008, 0x0002, 0x0000, 0x0000, 0x0003, 0x0001, 0x0000,
0x000b, 0xffff, 0x0003, 0x0000, 0x0000, 0x000b, 0xffff, 0x0008, 0x0002,
0x0000, 0x0000, 0x0003, 0x0032, 0x0000, 0x000b, 0x0000, 0x0008, 0x000a,
0x0000, 0x0066, 0x0075, 0x006c, 0x006c, 0x0000, 0x000b, 0x0000, 0x000b,
0x0000, 0x000b, 0xffff, 0x000b, 0xffff, 0x000b, 0x0000, 0x0008, 0x0002,
0x0000, 0x0000, 0x0008, 0x0002, 0x0000, 0x0000, 0x0008, 0x0002, 0x0000,
0x0000, 0x0008, 0x0002, 0x0000, 0x0000, 0x000b, 0x0000, 0x1815, 0x0000,
0x1a0c, 0x0000,
0
END
/////////////////////////////////////////////////////////////////////////////
//
// Icon
//
// Icon with lowest ID value placed first to ensure application icon
// remains consistent on all systems.
//
// the WMP icon comes from here:
// http://www.iconarchive.com/show/phuzion-icons-by-kyo-tux/Applic-WMP-icon.html
IDI_XCHAT ICON DISCARDABLE "wmpa.ico"
#endif // English (U.S.) resources
/////////////////////////////////////////////////////////////////////////////
#ifndef APSTUDIO_INVOKED
/////////////////////////////////////////////////////////////////////////////
//
// Generated from the TEXTINCLUDE 3 resource.
//
#define _AFX_NO_SPLITTER_RESOURCES
#define _AFX_NO_OLE_RESOURCES
#define _AFX_NO_TRACKER_RESOURCES
#define _AFX_NO_PROPERTY_RESOURCES
#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
#ifdef _WIN32
LANGUAGE 9, 1
#pragma code_page(1252)
#endif //_WIN32
#include "res\wmpa.rc2" // non-Microsoft Visual C++ edited resources
#include "afxres.rc" // Standard components
#endif
/////////////////////////////////////////////////////////////////////////////
#endif // not APSTUDIO_INVOKED

20
plugins/wmpa/wmpa.sln
View File

@ -1,20 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 11.00
# Visual Studio 2010
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "wmpa", "wmpa.vcxproj", "{08AD7C4D-DDDC-9545-A8D7-1808E6056143}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Release|Win32 = Release|Win32
Release|x64 = Release|x64
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{08AD7C4D-DDDC-9545-A8D7-1808E6056143}.Release|Win32.ActiveCfg = Release|Win32
{08AD7C4D-DDDC-9545-A8D7-1808E6056143}.Release|Win32.Build.0 = Release|Win32
{08AD7C4D-DDDC-9545-A8D7-1808E6056143}.Release|x64.ActiveCfg = Release|x64
{08AD7C4D-DDDC-9545-A8D7-1808E6056143}.Release|x64.Build.0 = Release|x64
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
EndGlobal

160
plugins/wmpa/wmpa.vcxproj
View File

@ -1,160 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project DefaultTargets="Build" ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup Label="ProjectConfigurations">
<ProjectConfiguration Include="Release|Win32">
<Configuration>Release</Configuration>
<Platform>Win32</Platform>
</ProjectConfiguration>
<ProjectConfiguration Include="Release|x64">
<Configuration>Release</Configuration>
<Platform>x64</Platform>
</ProjectConfiguration>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{E7F4DB0A-510D-41EF-B284-6E1DE1CC450D}</ProjectGuid>
<Keyword>Win32Proj</Keyword>
<RootNamespace>wmpa</RootNamespace>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>false</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
<UseOfMfc>Dynamic</UseOfMfc>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
<ConfigurationType>DynamicLibrary</ConfigurationType>
<UseDebugLibraries>false</UseDebugLibraries>
<WholeProgramOptimization>false</WholeProgramOptimization>
<CharacterSet>MultiByte</CharacterSet>
<UseOfMfc>Dynamic</UseOfMfc>
</PropertyGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
<ImportGroup Label="ExtensionSettings">
</ImportGroup>
<ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="..\..\win32\hexchat.props" />
</ImportGroup>
<ImportGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="PropertySheets">
<Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
<Import Project="..\..\win32\hexchat.props" />
</ImportGroup>
<PropertyGroup Label="UserMacros" />
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<LinkIncremental>false</LinkIncremental>
<TargetName>hcwmpa</TargetName>
<OutDir>$(HexChatBin)</OutDir>
<IntDir>$(HexChatObj)$(ProjectName)\</IntDir>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<LinkIncremental>false</LinkIncremental>
<TargetName>hcwmpa</TargetName>
<OutDir>$(HexChatBin)</OutDir>
<IntDir>$(HexChatObj)$(ProjectName)\</IntDir>
</PropertyGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
<ClCompile>
<PrecompiledHeader>Create</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;NDEBUG;_WINDOWS;_USRDLL;WMPA_EXPORTS;_AFXDLL;_AFX_NO_DAO_SUPPORT;_WIN32_WINNT=0x0501;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MultiProcessorCompilation>false</MultiProcessorCompilation>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<ModuleDefinitionFile>wmpa.def</ModuleDefinitionFile>
</Link>
<Midl>
<MkTypLibCompatible>true</MkTypLibCompatible>
</Midl>
</ItemDefinitionGroup>
<ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
<ClCompile>
<PrecompiledHeader>Create</PrecompiledHeader>
<Optimization>MaxSpeed</Optimization>
<FunctionLevelLinking>true</FunctionLevelLinking>
<IntrinsicFunctions>true</IntrinsicFunctions>
<PreprocessorDefinitions>WIN32;_WIN64;_AMD64_;NDEBUG;_WINDOWS;_USRDLL;WMPA_EXPORTS;_AFXDLL;_AFX_NO_DAO_SUPPORT;_WIN32_WINNT=0x0501;%(PreprocessorDefinitions)</PreprocessorDefinitions>
<MultiProcessorCompilation>false</MultiProcessorCompilation>
</ClCompile>
<Link>
<SubSystem>Windows</SubSystem>
<GenerateDebugInformation>true</GenerateDebugInformation>
<EnableCOMDATFolding>true</EnableCOMDATFolding>
<OptimizeReferences>true</OptimizeReferences>
<ModuleDefinitionFile>wmpa.def</ModuleDefinitionFile>
</Link>
<Midl>
<MkTypLibCompatible>true</MkTypLibCompatible>
</Midl>
</ItemDefinitionGroup>
<ItemGroup>
<ClCompile Include="StdAfx.cpp" />
<ClCompile Include="wmpa.cpp" />
<ClCompile Include="wmpadialog.cpp" />
<ClCompile Include="wmpcdrom.cpp" />
<ClCompile Include="wmpcdromcollection.cpp" />
<ClCompile Include="wmpclosedcaption.cpp" />
<ClCompile Include="wmpcontrols.cpp" />
<ClCompile Include="wmpdvd.cpp" />
<ClCompile Include="wmperror.cpp" />
<ClCompile Include="wmperroritem.cpp" />
<ClCompile Include="wmpmedia.cpp" />
<ClCompile Include="wmpmediacollection.cpp" />
<ClCompile Include="wmpnetwork.cpp" />
<ClCompile Include="wmpplayer4.cpp" />
<ClCompile Include="wmpplayerapplication.cpp" />
<ClCompile Include="wmpplaylist.cpp" />
<ClCompile Include="wmpplaylistarray.cpp" />
<ClCompile Include="wmpplaylistcollection.cpp" />
<ClCompile Include="wmpsettings.cpp" />
<ClCompile Include="wmpstringcollection.cpp" />
<ClCompile Include="hexchat-plugin.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="resource.h" />
<ClInclude Include="StdAfx.h" />
<ClInclude Include="wmpa.h" />
<ClInclude Include="wmpadialog.h" />
<ClInclude Include="wmpcdrom.h" />
<ClInclude Include="wmpcdromcollection.h" />
<ClInclude Include="wmpclosedcaption.h" />
<ClInclude Include="wmpcontrols.h" />
<ClInclude Include="wmpdvd.h" />
<ClInclude Include="wmperror.h" />
<ClInclude Include="wmperroritem.h" />
<ClInclude Include="wmpmedia.h" />
<ClInclude Include="wmpmediacollection.h" />
<ClInclude Include="wmpnetwork.h" />
<ClInclude Include="wmpplayer4.h" />
<ClInclude Include="wmpplayerapplication.h" />
<ClInclude Include="wmpplaylist.h" />
<ClInclude Include="wmpplaylistarray.h" />
<ClInclude Include="wmpplaylistcollection.h" />
<ClInclude Include="wmpsettings.h" />
<ClInclude Include="wmpstringcollection.h" />
<ClInclude Include="hexchat-plugin.h" />
</ItemGroup>
<ItemGroup>
<None Include="ReadMe.txt" />
<None Include="res\wmpa.rc2" />
<None Include="wmpa.aps" />
<None Include="wmpa.def" />
<None Include="wmpa.ico" />
</ItemGroup>
<ItemGroup>
<Midl Include="wmpa.odl" />
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="wmpa.rc" />
</ItemGroup>
<Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
<ImportGroup Label="ExtensionTargets">
</ImportGroup>
</Project>

180
plugins/wmpa/wmpa.vcxproj.filters
View File

@ -1,180 +0,0 @@
<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
<ItemGroup>
<Filter Include="Source Files">
<UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
<Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
</Filter>
<Filter Include="Header Files">
<UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
<Extensions>h;hpp;hxx;hm;inl;inc;xsd</Extensions>
</Filter>
<Filter Include="Resource Files">
<UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
<Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
</Filter>
<Filter Include="Resource Files\res">
<UniqueIdentifier>{c54ddc93-06ab-4a74-854a-9ec976b7bfd0}</UniqueIdentifier>
</Filter>
</ItemGroup>
<ItemGroup>
<ClCompile Include="StdAfx.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpa.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpadialog.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpcdrom.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpcdromcollection.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpclosedcaption.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpcontrols.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpdvd.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmperror.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmperroritem.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpmedia.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpmediacollection.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpnetwork.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpplayer4.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpplayerapplication.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpplaylist.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpplaylistarray.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpplaylistcollection.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpsettings.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="wmpstringcollection.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="hexchat-plugin.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="resource.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="StdAfx.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpa.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpadialog.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpcdrom.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpcdromcollection.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpclosedcaption.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpcontrols.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpdvd.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmperror.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmperroritem.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpmedia.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpmediacollection.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpnetwork.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpplayer4.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpplayerapplication.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpplaylist.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpplaylistarray.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpplaylistcollection.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpsettings.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="wmpstringcollection.h">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="hexchat-plugin.h">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
<ItemGroup>
<None Include="wmpa.aps">
<Filter>Resource Files</Filter>
</None>
<None Include="wmpa.def">
<Filter>Resource Files</Filter>
</None>
<None Include="wmpa.ico">
<Filter>Resource Files</Filter>
</None>
<None Include="ReadMe.txt">
<Filter>Resource Files</Filter>
</None>
<None Include="res\wmpa.rc2">
<Filter>Resource Files\res</Filter>
</None>
</ItemGroup>
<ItemGroup>
<Midl Include="wmpa.odl">
<Filter>Resource Files</Filter>
</Midl>
</ItemGroup>
<ItemGroup>
<ResourceCompile Include="wmpa.rc">
<Filter>Resource Files</Filter>
</ResourceCompile>
</ItemGroup>
</Project>

375
plugins/wmpa/wmpadialog.cpp
View File

@ -1,375 +0,0 @@
/******************************************************************
* $Id$
*
* $Log$
*
* Copyright © 2005 David Cullen, All rights reserved
*
******************************************************************/
#include "stdafx.h"
#include "wmpa.h"
#include "WMPADialog.h"
#include "shellapi.h"
#include "hexchat-plugin.h"
#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif
#define ID_TRAY_ICON 1000
#define WM_TRAY_ICON (WM_APP + 1)
/////////////////////////////////////////////////////////////////////////////
// CWMPADialog dialog
CWMPADialog::CWMPADialog(CWnd* pParent /*=NULL*/)
: CDialog(CWMPADialog::IDD, pParent)
{
EnableAutomation();
//{{AFX_DATA_INIT(CWMPADialog)
//}}AFX_DATA_INIT
}
void CWMPADialog::OnFinalRelease()
{
// When the last reference for an automation object is released
// OnFinalRelease is called. The base class will automatically
// deletes the object. Add additional cleanup required for your
// object before calling the base class.
CDialog::OnFinalRelease();
}
void CWMPADialog::DoDataExchange(CDataExchange* pDX)
{
CDialog::DoDataExchange(pDX);
//{{AFX_DATA_MAP(CWMPADialog)
DDX_Control(pDX, IDC_SONGLIST, m_SongListBox);
DDX_Control(pDX, IDC_PLAYLIST, m_PlaylistBox);
DDX_Control(pDX, IDC_WMP, m_WMP);
//}}AFX_DATA_MAP
}
BEGIN_MESSAGE_MAP(CWMPADialog, CDialog)
//{{AFX_MSG_MAP(CWMPADialog)
ON_LBN_DBLCLK(IDC_PLAYLIST, OnDblclkPlaylist)
ON_WM_SHOWWINDOW()
ON_WM_CLOSE()
ON_LBN_DBLCLK(IDC_SONGLIST, OnDblclkSonglist)
ON_WM_DESTROY()
ON_WM_SIZE()
//}}AFX_MSG_MAP
END_MESSAGE_MAP()
BEGIN_DISPATCH_MAP(CWMPADialog, CDialog)
//{{AFX_DISPATCH_MAP(CWMPADialog)
// NOTE - the ClassWizard will add and remove mapping macros here.
//}}AFX_DISPATCH_MAP
END_DISPATCH_MAP()
// Note: we add support for IID_IWMPADialog to support typesafe binding
// from VBA. This IID must match the GUID that is attached to the
// dispinterface in the .ODL file.
// {01C1B3AA-C7FC-4023-89A5-C814E1B62B9B}
static const IID IID_IWMPADialog =
{ 0x1c1b3aa, 0xc7fc, 0x4023, { 0x89, 0xa5, 0xc8, 0x14, 0xe1, 0xb6, 0x2b, 0x9b } };
BEGIN_INTERFACE_MAP(CWMPADialog, CDialog)
INTERFACE_PART(CWMPADialog, IID_IWMPADialog, Dispatch)
END_INTERFACE_MAP()
/////////////////////////////////////////////////////////////////////////////
// CWMPADialog message handlers
void CWMPADialog::OnDblclkPlaylist()
{
// TODO: Add your control notification handler code here
long index;
// Get the playlist name
index = m_PlaylistBox.GetCurSel();
CString playlistName;
m_PlaylistBox.GetText(index, playlistName);
// Get the playlist
CWMPPlaylistCollection pc = m_WMP.GetPlaylistCollection();
CWMPPlaylistArray pa = pc.getByName((LPCTSTR) playlistName);
CWMPPlaylist playlist = pa.Item(0);
m_WMP.SetCurrentPlaylist(playlist);
// Set the song list
UpdateSongList();
m_WMP.GetControls().play();
if (autoAnnounce) {
hexchat_commandf(ph, "me is playing %s", (LPCTSTR) wmpaGetSongTitle());
}
else {
hexchat_printf(ph, "WMPA: Playing %s", (LPCTSTR) wmpaGetSongTitle());
}
}
void CWMPADialog::OnShowWindow(BOOL bShow, UINT nStatus)
{
CDialog::OnShowWindow(bShow, nStatus);
// TODO: Add your message handler code here
if (bShow) {
if (!trayInit) {
ZeroMemory(&nid, sizeof(nid));
nid.cbSize = sizeof(nid);
nid.hWnd = m_hWnd;
nid.uID = ID_TRAY_ICON;
nid.uFlags = NIF_ICON | NIF_MESSAGE | NIF_TIP;
nid.uCallbackMessage = WM_TRAY_ICON;
nid.hIcon = m_hIcon;
strcpy(nid.szTip, "WMPA");
strcat(nid.szTip, VER_STRING);
strcat(nid.szTip, "\nWindows Media\nPlayer Announcer");
nid.dwState = 0;
nid.dwStateMask = 0;
strcpy(nid.szInfo, "WMPA ");
strcat(nid.szInfo, VER_STRING);
nid.uTimeout = 10000; // 10 second time out
strcat(nid.szInfoTitle, "WMPA");
nid.dwInfoFlags = 0;
trayInit = TRUE;
}
}
}
void CWMPADialog::PostNcDestroy()
{
// TODO: Add your specialized code here and/or call the base class
delete this;
CDialog::PostNcDestroy();
}
BOOL CWMPADialog::OnInitDialog()
{
CDialog::OnInitDialog();
CString title = "WMPA";
title += " ";
title += VER_STRING;
SetWindowText((LPCTSTR) title);
UpdatePlayLists();
autoAnnounce = FALSE;
trayInit = FALSE;
trayClicked = FALSE;
return TRUE; // return TRUE unless you set the focus to a control
// EXCEPTION: OCX Property Pages should return FALSE
}
void CWMPADialog::OnClose()
{
// TODO: Add your message handler code here and/or call default
Shell_NotifyIcon(NIM_ADD, &nid);
ShowWindow(SW_HIDE);
// Don't let the user close the dialog
// CDialog::OnClose();
}
void CWMPADialog::OnCancel()
{
// this->DestroyWindow();
}
void CWMPADialog::OnDblclkSonglist()
{
// TODO: Add your control notification handler code here
int index = m_SongListBox.GetCurSel();
m_WMP.GetControls().playItem(m_WMP.GetCurrentPlaylist().GetItem(index));
if (autoAnnounce) {
hexchat_commandf(ph, "me is playing %s", (LPCTSTR) wmpaGetSongTitle());
}
else {
hexchat_printf(ph, "WMPA: Playing %s", (LPCTSTR) wmpaGetSongTitle());
}
}
BEGIN_EVENTSINK_MAP(CWMPADialog, CDialog)
//{{AFX_EVENTSINK_MAP(CWMPADialog)
ON_EVENT(CWMPADialog, IDC_WMP, 5806 /* CurrentItemChange */, OnCurrentItemChangeWmp, VTS_DISPATCH)
ON_EVENT(CWMPADialog, IDC_WMP, 5101 /* PlayStateChange */, OnPlayStateChangeWmp, VTS_I4)
//}}AFX_EVENTSINK_MAP
END_EVENTSINK_MAP()
void CWMPADialog::OnCurrentItemChangeWmp(LPDISPATCH pdispMedia)
{
// TODO: Add your control notification handler code here
int state = m_WMP.GetPlayState();
if (state == 3) { // Playing
if (autoAnnounce) {
hexchat_commandf(ph, "me is playing %s", (LPCTSTR) wmpaGetSongTitle());
}
else {
hexchat_printf(ph, "WMPA: Playing %s", (LPCTSTR) wmpaGetSongTitle());
}
}
SelectCurrentSong();
}
void CWMPADialog::OnDestroy()
{
CDialog::OnDestroy();
// TODO: Add your message handler code here
}
void CWMPADialog::UpdateSongList()
{
char buffer[32];
CString name;
CString artist;
CString title;
CString album;
CString bitrate;
CString duration;
CString song;
long index;
long count;
m_SongListBox.ResetContent();
CWMPPlaylist playlist = m_WMP.GetCurrentPlaylist();
count = playlist.GetCount();
m_SongListBox.ResetContent();
for (index = 0; index < count; index++) {
name = playlist.GetItem(index).GetName();
artist = playlist.GetItem(index).getItemInfo("Artist");
title = playlist.GetItem(index).getItemInfo("Title");
album = playlist.GetItem(index).getItemInfo("Album");
bitrate = playlist.GetItem(index).getItemInfo("Bitrate");
duration = playlist.GetItem(index).GetDurationString();
long krate = strtoul((LPCTSTR) bitrate, NULL, 10) / 1000;
_ultoa(krate, buffer, 10);
bitrate = CString(buffer);
if (album.IsEmpty()) {
playlist.removeItem(playlist.GetItem(index));
count = playlist.GetCount();
}
else {
song = "";
song += artist;
if (song.IsEmpty()) song = "Various";
song += " - ";
song += title;
song += " (";
song += album;
song += ") [";
song += duration;
song += "/";
song += bitrate;
song += "Kbps]";
m_SongListBox.AddString((LPCTSTR) song);
}
}
m_SongListBox.SetCurSel(0);
}
void CWMPADialog::SelectCurrentSong()
{
CWMPMedia media;
long index;
long count;
count = m_WMP.GetCurrentPlaylist().GetCount();
for (index = 0; index < count; index++) {
media = m_WMP.GetCurrentPlaylist().GetItem(index);
if (m_WMP.GetCurrentMedia().GetIsIdentical(media)) {
m_SongListBox.SetCurSel(index);
}
}
}
void CWMPADialog::UpdatePlayLists()
{
// TODO: Add extra initialization here
CWMPPlaylistCollection pc = m_WMP.GetPlaylistCollection();
CWMPPlaylistArray pa = pc.getAll();
CWMPPlaylist playlist;
int index;
int count = pa.GetCount();
m_PlaylistBox.ResetContent();
for (index = 0; index < count; index++) {
playlist = pa.Item(index);
m_PlaylistBox.AddString((LPCTSTR) playlist.GetName());
}
}
void CWMPADialog::OnPlayStateChangeWmp(long NewState)
{
// TODO: Add your control notification handler code here
}
void CWMPADialog::OnSize(UINT nType, int cx, int cy)
{
CDialog::OnSize(nType, cx, cy);
// TODO: Add your message handler code here
switch (nType) {
case SIZE_MINIMIZED:
break;
case SIZE_RESTORED:
Shell_NotifyIcon(NIM_DELETE, &nid);
break;
default:
break;
}
}
LRESULT CWMPADialog::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
{
// TODO: Add your specialized code here and/or call the base class
switch (message) {
case WM_TRAY_ICON:
switch (lParam) {
case WM_LBUTTONDBLCLK:
trayClicked = TRUE;
break;
case WM_LBUTTONUP:
if (trayClicked == TRUE) {
ShowWindow(SW_RESTORE);
}
break;
default:
trayClicked = FALSE;
break;
}
return(TRUE);
break;
default:
return CDialog::WindowProc(message, wParam, lParam);
break;
}
}
void CWMPADialog::DeleteTrayIcon()
{
Shell_NotifyIcon(NIM_DELETE, &nid);
}

91
plugins/wmpa/wmpadialog.h
View File

@ -1,91 +0,0 @@
/******************************************************************
* $Id$
*
* $Log$
*
* Copyright © 2005 David Cullen, All rights reserved
*
******************************************************************/
//{{AFX_INCLUDES()
#include "wmpplayer4.h"
//}}AFX_INCLUDES
#if !defined(AFX_WMPADIALOG_H__D3838BCC_9E26_4FC0_BD42_C8D8EDF057E3__INCLUDED_)
#define AFX_WMPADIALOG_H__D3838BCC_9E26_4FC0_BD42_C8D8EDF057E3__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// WMPADialog.h : header file
//
/////////////////////////////////////////////////////////////////////////////
// CWMPADialog dialog
class CWMPADialog : public CDialog
{
// Construction
public:
CWMPADialog(CWnd* pParent = NULL); // standard constructor
virtual void OnCancel();
void UpdatePlayLists();
void UpdateSongList();
void SelectCurrentSong();
void DeleteTrayIcon();
BOOL autoAnnounce;
HICON m_hIcon;
private:
BOOL trayInit;
BOOL trayClicked;
NOTIFYICONDATA nid;
public:
// Dialog Data
//{{AFX_DATA(CWMPADialog)
enum { IDD = IDD_WMPADIALOG };
CListBox m_SongListBox;
CListBox m_PlaylistBox;
CWMPPlayer4 m_WMP;
//}}AFX_DATA
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CWMPADialog)
public:
virtual void OnFinalRelease();
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
virtual void PostNcDestroy();
virtual LRESULT WindowProc(UINT message, WPARAM wParam, LPARAM lParam);
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(CWMPADialog)
afx_msg void OnDblclkPlaylist();
afx_msg void OnShowWindow(BOOL bShow, UINT nStatus);
virtual BOOL OnInitDialog();
afx_msg void OnClose();
afx_msg void OnDblclkSonglist();
afx_msg void OnCurrentItemChangeWmp(LPDISPATCH pdispMedia);
afx_msg void OnDestroy();
afx_msg void OnPlayStateChangeWmp(long NewState);
afx_msg void OnSize(UINT nType, int cx, int cy);
DECLARE_EVENTSINK_MAP()
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
// Generated OLE dispatch map functions
//{{AFX_DISPATCH(CWMPADialog)
// NOTE - the ClassWizard will add and remove member functions here.
//}}AFX_DISPATCH
DECLARE_DISPATCH_MAP()
DECLARE_INTERFACE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPADIALOG_H__D3838BCC_9E26_4FC0_BD42_C8D8EDF057E3__INCLUDED_)

37
plugins/wmpa/wmpcdrom.cpp
View File

@ -1,37 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpcdrom.h"
// Dispatch interfaces referenced by this interface
#include "wmpplaylist.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPCdrom properties
/////////////////////////////////////////////////////////////////////////////
// CWMPCdrom operations
CString CWMPCdrom::GetDriveSpecifier()
{
CString result;
InvokeHelper(0xfb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
CWMPPlaylist CWMPCdrom::GetPlaylist()
{
LPDISPATCH pDispatch;
InvokeHelper(0xfc, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPPlaylist(pDispatch);
}
void CWMPCdrom::eject()
{
InvokeHelper(0xfd, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

39
plugins/wmpa/wmpcdrom.h
View File

@ -1,39 +0,0 @@
#if !defined(AFX_WMPCDROM_H__B7B13CE9_E69E_4D54_9370_CCA2D4A42532__INCLUDED_)
#define AFX_WMPCDROM_H__B7B13CE9_E69E_4D54_9370_CCA2D4A42532__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
// Dispatch interfaces referenced by this interface
class CWMPPlaylist;
/////////////////////////////////////////////////////////////////////////////
// CWMPCdrom wrapper class
class CWMPCdrom : public COleDispatchDriver
{
public:
CWMPCdrom() {} // Calls COleDispatchDriver default constructor
CWMPCdrom(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPCdrom(const CWMPCdrom& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
CString GetDriveSpecifier();
CWMPPlaylist GetPlaylist();
void eject();
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPCDROM_H__B7B13CE9_E69E_4D54_9370_CCA2D4A42532__INCLUDED_)

45
plugins/wmpa/wmpcdromcollection.cpp
View File

@ -1,45 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpcdromcollection.h"
// Dispatch interfaces referenced by this interface
#include "WMPCdrom.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPCdromCollection properties
/////////////////////////////////////////////////////////////////////////////
// CWMPCdromCollection operations
long CWMPCdromCollection::GetCount()
{
long result;
InvokeHelper(0x12d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
CWMPCdrom CWMPCdromCollection::Item(long lIndex)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x12e, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
lIndex);
return CWMPCdrom(pDispatch);
}
CWMPCdrom CWMPCdromCollection::getByDriveSpecifier(LPCTSTR bstrDriveSpecifier)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x12f, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrDriveSpecifier);
return CWMPCdrom(pDispatch);
}

39
plugins/wmpa/wmpcdromcollection.h
View File

@ -1,39 +0,0 @@
#if !defined(AFX_WMPCDROMCOLLECTION_H__35F03E65_DBA5_47A8_84C1_DAA3D624A4D3__INCLUDED_)
#define AFX_WMPCDROMCOLLECTION_H__35F03E65_DBA5_47A8_84C1_DAA3D624A4D3__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
// Dispatch interfaces referenced by this interface
class CWMPCdrom;
/////////////////////////////////////////////////////////////////////////////
// CWMPCdromCollection wrapper class
class CWMPCdromCollection : public COleDispatchDriver
{
public:
CWMPCdromCollection() {} // Calls COleDispatchDriver default constructor
CWMPCdromCollection(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPCdromCollection(const CWMPCdromCollection& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
long GetCount();
CWMPCdrom Item(long lIndex);
CWMPCdrom getByDriveSpecifier(LPCTSTR bstrDriveSpecifier);
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPCDROMCOLLECTION_H__35F03E65_DBA5_47A8_84C1_DAA3D624A4D3__INCLUDED_)

75
plugins/wmpa/wmpclosedcaption.cpp
View File

@ -1,75 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpclosedcaption.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPClosedCaption properties
/////////////////////////////////////////////////////////////////////////////
// CWMPClosedCaption operations
CString CWMPClosedCaption::GetSAMIStyle()
{
CString result;
InvokeHelper(0x3b7, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPClosedCaption::SetSAMIStyle(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3b7, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}
CString CWMPClosedCaption::GetSAMILang()
{
CString result;
InvokeHelper(0x3b8, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPClosedCaption::SetSAMILang(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3b8, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}
CString CWMPClosedCaption::GetSAMIFileName()
{
CString result;
InvokeHelper(0x3b9, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPClosedCaption::SetSAMIFileName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3b9, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}
CString CWMPClosedCaption::GetCaptioningId()
{
CString result;
InvokeHelper(0x3ba, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPClosedCaption::SetCaptioningId(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3ba, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}

40
plugins/wmpa/wmpclosedcaption.h
View File

@ -1,40 +0,0 @@
#if !defined(AFX_WMPCLOSEDCAPTION_H__FC0A9836_7517_4898_B25C_74C76E80CE3D__INCLUDED_)
#define AFX_WMPCLOSEDCAPTION_H__FC0A9836_7517_4898_B25C_74C76E80CE3D__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
/////////////////////////////////////////////////////////////////////////////
// CWMPClosedCaption wrapper class
class CWMPClosedCaption : public COleDispatchDriver
{
public:
CWMPClosedCaption() {} // Calls COleDispatchDriver default constructor
CWMPClosedCaption(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPClosedCaption(const CWMPClosedCaption& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
CString GetSAMIStyle();
void SetSAMIStyle(LPCTSTR lpszNewValue);
CString GetSAMILang();
void SetSAMILang(LPCTSTR lpszNewValue);
CString GetSAMIFileName();
void SetSAMIFileName(LPCTSTR lpszNewValue);
CString GetCaptioningId();
void SetCaptioningId(LPCTSTR lpszNewValue);
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPCLOSEDCAPTION_H__FC0A9836_7517_4898_B25C_74C76E80CE3D__INCLUDED_)

123
plugins/wmpa/wmpcontrols.cpp
View File

@ -1,123 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpcontrols.h"
// Dispatch interfaces referenced by this interface
#include "wmpmedia.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPControls properties
/////////////////////////////////////////////////////////////////////////////
// CWMPControls operations
BOOL CWMPControls::GetIsAvailable(LPCTSTR bstrItem)
{
BOOL result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3e, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
bstrItem);
return result;
}
void CWMPControls::play()
{
InvokeHelper(0x33, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
void CWMPControls::stop()
{
InvokeHelper(0x34, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
void CWMPControls::pause()
{
InvokeHelper(0x35, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
void CWMPControls::fastForward()
{
InvokeHelper(0x36, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
void CWMPControls::fastReverse()
{
InvokeHelper(0x37, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
double CWMPControls::GetCurrentPosition()
{
double result;
InvokeHelper(0x38, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
return result;
}
void CWMPControls::SetCurrentPosition(double newValue)
{
static BYTE parms[] =
VTS_R8;
InvokeHelper(0x38, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}
CString CWMPControls::GetCurrentPositionString()
{
CString result;
InvokeHelper(0x39, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPControls::next()
{
InvokeHelper(0x3a, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
void CWMPControls::previous()
{
InvokeHelper(0x3b, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
CWMPMedia CWMPControls::GetCurrentItem()
{
LPDISPATCH pDispatch;
InvokeHelper(0x3c, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPMedia(pDispatch);
}
void CWMPControls::SetCurrentItem(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x3c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}
long CWMPControls::GetCurrentMarker()
{
long result;
InvokeHelper(0x3d, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
void CWMPControls::SetCurrentMarker(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x3d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}
void CWMPControls::playItem(LPDISPATCH pIWMPMedia)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x3f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
pIWMPMedia);
}

52
plugins/wmpa/wmpcontrols.h
View File

@ -1,52 +0,0 @@
#if !defined(AFX_WMPCONTROLS_H__234DACEF_6ED9_481D_B7E8_03653189E9B2__INCLUDED_)
#define AFX_WMPCONTROLS_H__234DACEF_6ED9_481D_B7E8_03653189E9B2__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
// Dispatch interfaces referenced by this interface
class CWMPMedia;
/////////////////////////////////////////////////////////////////////////////
// CWMPControls wrapper class
class CWMPControls : public COleDispatchDriver
{
public:
CWMPControls() {} // Calls COleDispatchDriver default constructor
CWMPControls(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPControls(const CWMPControls& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
BOOL GetIsAvailable(LPCTSTR bstrItem);
void play();
void stop();
void pause();
void fastForward();
void fastReverse();
double GetCurrentPosition();
void SetCurrentPosition(double newValue);
CString GetCurrentPositionString();
void next();
void previous();
CWMPMedia GetCurrentItem();
void SetCurrentItem(LPDISPATCH newValue);
long GetCurrentMarker();
void SetCurrentMarker(long nNewValue);
void playItem(LPDISPATCH pIWMPMedia);
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPCONTROLS_H__234DACEF_6ED9_481D_B7E8_03653189E9B2__INCLUDED_)

52
plugins/wmpa/wmpdvd.cpp
View File

@ -1,52 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpdvd.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPDVD properties
/////////////////////////////////////////////////////////////////////////////
// CWMPDVD operations
BOOL CWMPDVD::GetIsAvailable(LPCTSTR bstrItem)
{
BOOL result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x3e9, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
bstrItem);
return result;
}
CString CWMPDVD::GetDomain()
{
CString result;
InvokeHelper(0x3ea, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPDVD::topMenu()
{
InvokeHelper(0x3eb, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
void CWMPDVD::titleMenu()
{
InvokeHelper(0x3ec, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
void CWMPDVD::back()
{
InvokeHelper(0x3ed, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
void CWMPDVD::resume()
{
InvokeHelper(0x3ee, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

38
plugins/wmpa/wmpdvd.h
View File

@ -1,38 +0,0 @@
#if !defined(AFX_WMPDVD_H__E83D86CA_08B8_4ACA_A434_0837BA71E3CA__INCLUDED_)
#define AFX_WMPDVD_H__E83D86CA_08B8_4ACA_A434_0837BA71E3CA__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
/////////////////////////////////////////////////////////////////////////////
// CWMPDVD wrapper class
class CWMPDVD : public COleDispatchDriver
{
public:
CWMPDVD() {} // Calls COleDispatchDriver default constructor
CWMPDVD(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPDVD(const CWMPDVD& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
BOOL GetIsAvailable(LPCTSTR bstrItem);
CString GetDomain();
void topMenu();
void titleMenu();
void back();
void resume();
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPDVD_H__E83D86CA_08B8_4ACA_A434_0837BA71E3CA__INCLUDED_)

45
plugins/wmpa/wmperror.cpp
View File

@ -1,45 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmperror.h"
// Dispatch interfaces referenced by this interface
#include "wmperroritem.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPError properties
/////////////////////////////////////////////////////////////////////////////
// CWMPError operations
void CWMPError::clearErrorQueue()
{
InvokeHelper(0x353, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
long CWMPError::GetErrorCount()
{
long result;
InvokeHelper(0x354, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
CWMPErrorItem CWMPError::GetItem(long dwIndex)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x355, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, parms,
dwIndex);
return CWMPErrorItem(pDispatch);
}
void CWMPError::webHelp()
{
InvokeHelper(0x356, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}

40
plugins/wmpa/wmperror.h
View File

@ -1,40 +0,0 @@
#if !defined(AFX_WMPERROR_H__1E72AC7F_E0AC_4100_B7EF_A5B0D8FA75C3__INCLUDED_)
#define AFX_WMPERROR_H__1E72AC7F_E0AC_4100_B7EF_A5B0D8FA75C3__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
// Dispatch interfaces referenced by this interface
class CWMPErrorItem;
/////////////////////////////////////////////////////////////////////////////
// CWMPError wrapper class
class CWMPError : public COleDispatchDriver
{
public:
CWMPError() {} // Calls COleDispatchDriver default constructor
CWMPError(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPError(const CWMPError& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
void clearErrorQueue();
long GetErrorCount();
CWMPErrorItem GetItem(long dwIndex);
void webHelp();
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPERROR_H__1E72AC7F_E0AC_4100_B7EF_A5B0D8FA75C3__INCLUDED_)

50
plugins/wmpa/wmperroritem.cpp
View File

@ -1,50 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmperroritem.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPErrorItem properties
/////////////////////////////////////////////////////////////////////////////
// CWMPErrorItem operations
long CWMPErrorItem::GetErrorCode()
{
long result;
InvokeHelper(0x385, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
CString CWMPErrorItem::GetErrorDescription()
{
CString result;
InvokeHelper(0x386, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
VARIANT CWMPErrorItem::GetErrorContext()
{
VARIANT result;
InvokeHelper(0x387, DISPATCH_PROPERTYGET, VT_VARIANT, (void*)&result, NULL);
return result;
}
long CWMPErrorItem::GetRemedy()
{
long result;
InvokeHelper(0x388, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
CString CWMPErrorItem::GetCustomUrl()
{
CString result;
InvokeHelper(0x389, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}

37
plugins/wmpa/wmperroritem.h
View File

@ -1,37 +0,0 @@
#if !defined(AFX_WMPERRORITEM_H__9399BDE5_C96D_43D3_BF02_E7A5850421B4__INCLUDED_)
#define AFX_WMPERRORITEM_H__9399BDE5_C96D_43D3_BF02_E7A5850421B4__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
/////////////////////////////////////////////////////////////////////////////
// CWMPErrorItem wrapper class
class CWMPErrorItem : public COleDispatchDriver
{
public:
CWMPErrorItem() {} // Calls COleDispatchDriver default constructor
CWMPErrorItem(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPErrorItem(const CWMPErrorItem& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
long GetErrorCode();
CString GetErrorDescription();
VARIANT GetErrorContext();
long GetRemedy();
CString GetCustomUrl();
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPERRORITEM_H__9399BDE5_C96D_43D3_BF02_E7A5850421B4__INCLUDED_)

167
plugins/wmpa/wmpmedia.cpp
View File

@ -1,167 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpmedia.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPMedia properties
/////////////////////////////////////////////////////////////////////////////
// CWMPMedia operations
BOOL CWMPMedia::GetIsIdentical(LPDISPATCH pIWMPMedia)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x2fb, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
pIWMPMedia);
return result;
}
CString CWMPMedia::GetSourceURL()
{
CString result;
InvokeHelper(0x2ef, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
CString CWMPMedia::GetName()
{
CString result;
InvokeHelper(0x2fc, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPMedia::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2fc, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}
long CWMPMedia::GetImageSourceWidth()
{
long result;
InvokeHelper(0x2f0, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPMedia::GetImageSourceHeight()
{
long result;
InvokeHelper(0x2f1, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPMedia::GetMarkerCount()
{
long result;
InvokeHelper(0x2f2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
double CWMPMedia::getMarkerTime(long MarkerNum)
{
double result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2f3, DISPATCH_METHOD, VT_R8, (void*)&result, parms,
MarkerNum);
return result;
}
CString CWMPMedia::getMarkerName(long MarkerNum)
{
CString result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2f4, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
MarkerNum);
return result;
}
double CWMPMedia::GetDuration()
{
double result;
InvokeHelper(0x2f5, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
return result;
}
CString CWMPMedia::GetDurationString()
{
CString result;
InvokeHelper(0x2f6, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
long CWMPMedia::GetAttributeCount()
{
long result;
InvokeHelper(0x2f7, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
CString CWMPMedia::getAttributeName(long lIndex)
{
CString result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2f8, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
lIndex);
return result;
}
CString CWMPMedia::getItemInfo(LPCTSTR bstrItemName)
{
CString result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2f9, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
bstrItemName);
return result;
}
void CWMPMedia::setItemInfo(LPCTSTR bstrItemName, LPCTSTR bstrVal)
{
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0x2fa, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
bstrItemName, bstrVal);
}
CString CWMPMedia::getItemInfoByAtom(long lAtom)
{
CString result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x2fd, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
lAtom);
return result;
}
BOOL CWMPMedia::isMemberOf(LPDISPATCH pPlaylist)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x2fe, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
pPlaylist);
return result;
}
BOOL CWMPMedia::isReadOnlyItem(LPCTSTR bstrItemName)
{
BOOL result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2ff, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
bstrItemName);
return result;
}

50
plugins/wmpa/wmpmedia.h
View File

@ -1,50 +0,0 @@
#if !defined(AFX_WMPMEDIA_H__7736565E_C037_498E_89F1_9696912C5998__INCLUDED_)
#define AFX_WMPMEDIA_H__7736565E_C037_498E_89F1_9696912C5998__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
/////////////////////////////////////////////////////////////////////////////
// CWMPMedia wrapper class
class CWMPMedia : public COleDispatchDriver
{
public:
CWMPMedia() {} // Calls COleDispatchDriver default constructor
CWMPMedia(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPMedia(const CWMPMedia& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
BOOL GetIsIdentical(LPDISPATCH pIWMPMedia);
CString GetSourceURL();
CString GetName();
void SetName(LPCTSTR lpszNewValue);
long GetImageSourceWidth();
long GetImageSourceHeight();
long GetMarkerCount();
double getMarkerTime(long MarkerNum);
CString getMarkerName(long MarkerNum);
double GetDuration();
CString GetDurationString();
long GetAttributeCount();
CString getAttributeName(long lIndex);
CString getItemInfo(LPCTSTR bstrItemName);
void setItemInfo(LPCTSTR bstrItemName, LPCTSTR bstrVal);
CString getItemInfoByAtom(long lAtom);
BOOL isMemberOf(LPDISPATCH pPlaylist);
BOOL isReadOnlyItem(LPCTSTR bstrItemName);
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPMEDIA_H__7736565E_C037_498E_89F1_9696912C5998__INCLUDED_)

133
plugins/wmpa/wmpmediacollection.cpp
View File

@ -1,133 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpmediacollection.h"
// Dispatch interfaces referenced by this interface
#include "wmpmedia.h"
#include "wmpplaylist.h"
#include "wmpstringcollection.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPMediaCollection properties
/////////////////////////////////////////////////////////////////////////////
// CWMPMediaCollection operations
CWMPMedia CWMPMediaCollection::add(LPCTSTR bstrURL)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1c4, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrURL);
return CWMPMedia(pDispatch);
}
CWMPPlaylist CWMPMediaCollection::getAll()
{
LPDISPATCH pDispatch;
InvokeHelper(0x1c5, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPPlaylist(pDispatch);
}
CWMPPlaylist CWMPMediaCollection::getByName(LPCTSTR bstrName)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1c6, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrName);
return CWMPPlaylist(pDispatch);
}
CWMPPlaylist CWMPMediaCollection::getByGenre(LPCTSTR bstrGenre)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1c7, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrGenre);
return CWMPPlaylist(pDispatch);
}
CWMPPlaylist CWMPMediaCollection::getByAuthor(LPCTSTR bstrAuthor)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1c8, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrAuthor);
return CWMPPlaylist(pDispatch);
}
CWMPPlaylist CWMPMediaCollection::getByAlbum(LPCTSTR bstrAlbum)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1c9, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrAlbum);
return CWMPPlaylist(pDispatch);
}
CWMPPlaylist CWMPMediaCollection::getByAttribute(LPCTSTR bstrAttribute, LPCTSTR bstrValue)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0x1ca, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrAttribute, bstrValue);
return CWMPPlaylist(pDispatch);
}
void CWMPMediaCollection::remove(LPDISPATCH pItem, BOOL varfDeleteFile)
{
static BYTE parms[] =
VTS_DISPATCH VTS_BOOL;
InvokeHelper(0x1cb, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
pItem, varfDeleteFile);
}
CWMPStringCollection CWMPMediaCollection::getAttributeStringCollection(LPCTSTR bstrAttribute, LPCTSTR bstrMediaType)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0x1cd, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrAttribute, bstrMediaType);
return CWMPStringCollection(pDispatch);
}
long CWMPMediaCollection::getMediaAtom(LPCTSTR bstrItemName)
{
long result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1d6, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
bstrItemName);
return result;
}
void CWMPMediaCollection::setDeleted(LPDISPATCH pItem, BOOL varfIsDeleted)
{
static BYTE parms[] =
VTS_DISPATCH VTS_BOOL;
InvokeHelper(0x1d7, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
pItem, varfIsDeleted);
}
BOOL CWMPMediaCollection::isDeleted(LPDISPATCH pItem)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x1d8, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
pItem);
return result;
}

50
plugins/wmpa/wmpmediacollection.h
View File

@ -1,50 +0,0 @@
#if !defined(AFX_WMPMEDIACOLLECTION_H__8C47EB0E_4638_46DA_A405_415AEAE509CE__INCLUDED_)
#define AFX_WMPMEDIACOLLECTION_H__8C47EB0E_4638_46DA_A405_415AEAE509CE__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
// Dispatch interfaces referenced by this interface
class CWMPMedia;
class CWMPPlaylist;
class CWMPStringCollection;
/////////////////////////////////////////////////////////////////////////////
// CWMPMediaCollection wrapper class
class CWMPMediaCollection : public COleDispatchDriver
{
public:
CWMPMediaCollection() {} // Calls COleDispatchDriver default constructor
CWMPMediaCollection(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPMediaCollection(const CWMPMediaCollection& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
CWMPMedia add(LPCTSTR bstrURL);
CWMPPlaylist getAll();
CWMPPlaylist getByName(LPCTSTR bstrName);
CWMPPlaylist getByGenre(LPCTSTR bstrGenre);
CWMPPlaylist getByAuthor(LPCTSTR bstrAuthor);
CWMPPlaylist getByAlbum(LPCTSTR bstrAlbum);
CWMPPlaylist getByAttribute(LPCTSTR bstrAttribute, LPCTSTR bstrValue);
void remove(LPDISPATCH pItem, BOOL varfDeleteFile);
CWMPStringCollection getAttributeStringCollection(LPCTSTR bstrAttribute, LPCTSTR bstrMediaType);
long getMediaAtom(LPCTSTR bstrItemName);
void setDeleted(LPDISPATCH pItem, BOOL varfIsDeleted);
BOOL isDeleted(LPDISPATCH pItem);
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPMEDIACOLLECTION_H__8C47EB0E_4638_46DA_A405_415AEAE509CE__INCLUDED_)

233
plugins/wmpa/wmpnetwork.cpp
View File

@ -1,233 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpnetwork.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPNetwork properties
/////////////////////////////////////////////////////////////////////////////
// CWMPNetwork operations
long CWMPNetwork::GetBandWidth()
{
long result;
InvokeHelper(0x321, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPNetwork::GetRecoveredPackets()
{
long result;
InvokeHelper(0x322, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
CString CWMPNetwork::GetSourceProtocol()
{
CString result;
InvokeHelper(0x323, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
long CWMPNetwork::GetReceivedPackets()
{
long result;
InvokeHelper(0x324, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPNetwork::GetLostPackets()
{
long result;
InvokeHelper(0x325, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPNetwork::GetReceptionQuality()
{
long result;
InvokeHelper(0x326, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPNetwork::GetBufferingCount()
{
long result;
InvokeHelper(0x327, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPNetwork::GetBufferingProgress()
{
long result;
InvokeHelper(0x328, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPNetwork::GetBufferingTime()
{
long result;
InvokeHelper(0x329, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
void CWMPNetwork::SetBufferingTime(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x329, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}
long CWMPNetwork::GetFrameRate()
{
long result;
InvokeHelper(0x32a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPNetwork::GetMaxBitRate()
{
long result;
InvokeHelper(0x32b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPNetwork::GetBitRate()
{
long result;
InvokeHelper(0x32c, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPNetwork::getProxySettings(LPCTSTR bstrProtocol)
{
long result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x32d, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
bstrProtocol);
return result;
}
void CWMPNetwork::setProxySettings(LPCTSTR bstrProtocol, long lProxySetting)
{
static BYTE parms[] =
VTS_BSTR VTS_I4;
InvokeHelper(0x32e, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
bstrProtocol, lProxySetting);
}
CString CWMPNetwork::getProxyName(LPCTSTR bstrProtocol)
{
CString result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x32f, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
bstrProtocol);
return result;
}
void CWMPNetwork::setProxyName(LPCTSTR bstrProtocol, LPCTSTR bstrProxyName)
{
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0x330, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
bstrProtocol, bstrProxyName);
}
long CWMPNetwork::getProxyPort(LPCTSTR bstrProtocol)
{
long result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x331, DISPATCH_METHOD, VT_I4, (void*)&result, parms,
bstrProtocol);
return result;
}
void CWMPNetwork::setProxyPort(LPCTSTR bstrProtocol, long lProxyPort)
{
static BYTE parms[] =
VTS_BSTR VTS_I4;
InvokeHelper(0x332, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
bstrProtocol, lProxyPort);
}
CString CWMPNetwork::getProxyExceptionList(LPCTSTR bstrProtocol)
{
CString result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x333, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
bstrProtocol);
return result;
}
void CWMPNetwork::setProxyExceptionList(LPCTSTR bstrProtocol, LPCTSTR pbstrExceptionList)
{
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0x334, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
bstrProtocol, pbstrExceptionList);
}
BOOL CWMPNetwork::getProxyBypassForLocal(LPCTSTR bstrProtocol)
{
BOOL result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x335, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
bstrProtocol);
return result;
}
void CWMPNetwork::setProxyBypassForLocal(LPCTSTR bstrProtocol, BOOL fBypassForLocal)
{
static BYTE parms[] =
VTS_BSTR VTS_BOOL;
InvokeHelper(0x336, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
bstrProtocol, fBypassForLocal);
}
long CWMPNetwork::GetMaxBandwidth()
{
long result;
InvokeHelper(0x337, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
void CWMPNetwork::SetMaxBandwidth(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x337, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}
long CWMPNetwork::GetDownloadProgress()
{
long result;
InvokeHelper(0x338, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPNetwork::GetEncodedFrameRate()
{
long result;
InvokeHelper(0x339, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPNetwork::GetFramesSkipped()
{
long result;
InvokeHelper(0x33a, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}

60
plugins/wmpa/wmpnetwork.h
View File

@ -1,60 +0,0 @@
#if !defined(AFX_WMPNETWORK_H__50BDAB41_9F78_492A_8A5E_27543B0C0CAF__INCLUDED_)
#define AFX_WMPNETWORK_H__50BDAB41_9F78_492A_8A5E_27543B0C0CAF__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
/////////////////////////////////////////////////////////////////////////////
// CWMPNetwork wrapper class
class CWMPNetwork : public COleDispatchDriver
{
public:
CWMPNetwork() {} // Calls COleDispatchDriver default constructor
CWMPNetwork(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPNetwork(const CWMPNetwork& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
long GetBandWidth();
long GetRecoveredPackets();
CString GetSourceProtocol();
long GetReceivedPackets();
long GetLostPackets();
long GetReceptionQuality();
long GetBufferingCount();
long GetBufferingProgress();
long GetBufferingTime();
void SetBufferingTime(long nNewValue);
long GetFrameRate();
long GetMaxBitRate();
long GetBitRate();
long getProxySettings(LPCTSTR bstrProtocol);
void setProxySettings(LPCTSTR bstrProtocol, long lProxySetting);
CString getProxyName(LPCTSTR bstrProtocol);
void setProxyName(LPCTSTR bstrProtocol, LPCTSTR bstrProxyName);
long getProxyPort(LPCTSTR bstrProtocol);
void setProxyPort(LPCTSTR bstrProtocol, long lProxyPort);
CString getProxyExceptionList(LPCTSTR bstrProtocol);
void setProxyExceptionList(LPCTSTR bstrProtocol, LPCTSTR pbstrExceptionList);
BOOL getProxyBypassForLocal(LPCTSTR bstrProtocol);
void setProxyBypassForLocal(LPCTSTR bstrProtocol, BOOL fBypassForLocal);
long GetMaxBandwidth();
void SetMaxBandwidth(long nNewValue);
long GetDownloadProgress();
long GetEncodedFrameRate();
long GetFramesSkipped();
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPNETWORK_H__50BDAB41_9F78_492A_8A5E_27543B0C0CAF__INCLUDED_)

321
plugins/wmpa/wmpplayer4.cpp
View File

@ -1,321 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpplayer4.h"
// Dispatch interfaces referenced by this interface
#include "wmpcontrols.h"
#include "WMPSettings.h"
#include "wmpmedia.h"
#include "wmpmediacollection.h"
#include "wmpplaylistcollection.h"
#include "wmpnetwork.h"
#include "wmpplaylist.h"
#include "wmpcdromcollection.h"
#include "wmpclosedcaption.h"
#include "WMPError.h"
#include "wmpdvd.h"
#include "WMPPlayerApplication.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPPlayer4
IMPLEMENT_DYNCREATE(CWMPPlayer4, CWnd)
/////////////////////////////////////////////////////////////////////////////
// CWMPPlayer4 properties
/////////////////////////////////////////////////////////////////////////////
// CWMPPlayer4 operations
void CWMPPlayer4::close()
{
InvokeHelper(0x3, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
CString CWMPPlayer4::GetUrl()
{
CString result;
InvokeHelper(0x1, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPPlayer4::SetUrl(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}
long CWMPPlayer4::GetOpenState()
{
long result;
InvokeHelper(0x2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
long CWMPPlayer4::GetPlayState()
{
long result;
InvokeHelper(0xa, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
CWMPControls CWMPPlayer4::GetControls()
{
LPDISPATCH pDispatch;
InvokeHelper(0x4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPControls(pDispatch);
}
CWMPSettings CWMPPlayer4::GetSettings()
{
LPDISPATCH pDispatch;
InvokeHelper(0x5, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPSettings(pDispatch);
}
CWMPMedia CWMPPlayer4::GetCurrentMedia()
{
LPDISPATCH pDispatch;
InvokeHelper(0x6, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPMedia(pDispatch);
}
void CWMPPlayer4::SetCurrentMedia(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x6, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}
CWMPMediaCollection CWMPPlayer4::GetMediaCollection()
{
LPDISPATCH pDispatch;
InvokeHelper(0x8, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPMediaCollection(pDispatch);
}
CWMPPlaylistCollection CWMPPlayer4::GetPlaylistCollection()
{
LPDISPATCH pDispatch;
InvokeHelper(0x9, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPPlaylistCollection(pDispatch);
}
CString CWMPPlayer4::GetVersionInfo()
{
CString result;
InvokeHelper(0xb, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPPlayer4::launchURL(LPCTSTR bstrURL)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
bstrURL);
}
CWMPNetwork CWMPPlayer4::GetNetwork()
{
LPDISPATCH pDispatch;
InvokeHelper(0x7, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPNetwork(pDispatch);
}
CWMPPlaylist CWMPPlayer4::GetCurrentPlaylist()
{
LPDISPATCH pDispatch;
InvokeHelper(0xd, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPPlaylist(pDispatch);
}
void CWMPPlayer4::SetCurrentPlaylist(LPDISPATCH newValue)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xd, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}
CWMPCdromCollection CWMPPlayer4::GetCdromCollection()
{
LPDISPATCH pDispatch;
InvokeHelper(0xe, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPCdromCollection(pDispatch);
}
CWMPClosedCaption CWMPPlayer4::GetClosedCaption()
{
LPDISPATCH pDispatch;
InvokeHelper(0xf, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPClosedCaption(pDispatch);
}
BOOL CWMPPlayer4::GetIsOnline()
{
BOOL result;
InvokeHelper(0x10, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
CWMPError CWMPPlayer4::GetError()
{
LPDISPATCH pDispatch;
InvokeHelper(0x11, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPError(pDispatch);
}
CString CWMPPlayer4::GetStatus()
{
CString result;
InvokeHelper(0x12, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
CWMPDVD CWMPPlayer4::GetDvd()
{
LPDISPATCH pDispatch;
InvokeHelper(0x28, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPDVD(pDispatch);
}
CWMPPlaylist CWMPPlayer4::newPlaylist(LPCTSTR bstrName, LPCTSTR bstrURL)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0x29, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrName, bstrURL);
return CWMPPlaylist(pDispatch);
}
CWMPMedia CWMPPlayer4::newMedia(LPCTSTR bstrURL)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x2a, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrURL);
return CWMPMedia(pDispatch);
}
BOOL CWMPPlayer4::GetEnabled()
{
BOOL result;
InvokeHelper(0x13, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
void CWMPPlayer4::SetEnabled(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x13, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}
BOOL CWMPPlayer4::GetFullScreen()
{
BOOL result;
InvokeHelper(0x15, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
void CWMPPlayer4::SetFullScreen(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x15, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}
BOOL CWMPPlayer4::GetEnableContextMenu()
{
BOOL result;
InvokeHelper(0x16, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
void CWMPPlayer4::SetEnableContextMenu(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x16, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}
void CWMPPlayer4::SetUiMode(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x17, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}
CString CWMPPlayer4::GetUiMode()
{
CString result;
InvokeHelper(0x17, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
BOOL CWMPPlayer4::GetStretchToFit()
{
BOOL result;
InvokeHelper(0x18, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
void CWMPPlayer4::SetStretchToFit(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x18, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}
BOOL CWMPPlayer4::GetWindowlessVideo()
{
BOOL result;
InvokeHelper(0x19, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
void CWMPPlayer4::SetWindowlessVideo(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x19, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}
BOOL CWMPPlayer4::GetIsRemote()
{
BOOL result;
InvokeHelper(0x1a, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
CWMPPlayerApplication CWMPPlayer4::GetPlayerApplication()
{
LPDISPATCH pDispatch;
InvokeHelper(0x1b, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPPlayerApplication(pDispatch);
}
void CWMPPlayer4::openPlayer(LPCTSTR bstrURL)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x1c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
bstrURL);
}

104
plugins/wmpa/wmpplayer4.h
View File

@ -1,104 +0,0 @@
#if !defined(AFX_WMPPLAYER4_H__A318AE12_803B_4EED_B586_1395637CDD35__INCLUDED_)
#define AFX_WMPPLAYER4_H__A318AE12_803B_4EED_B586_1395637CDD35__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
// Dispatch interfaces referenced by this interface
class CWMPControls;
class CWMPSettings;
class CWMPMedia;
class CWMPMediaCollection;
class CWMPPlaylistCollection;
class CWMPNetwork;
class CWMPPlaylist;
class CWMPCdromCollection;
class CWMPClosedCaption;
class CWMPError;
class CWMPDVD;
class CWMPPlayerApplication;
/////////////////////////////////////////////////////////////////////////////
// CWMPPlayer4 wrapper class
class CWMPPlayer4 : public CWnd
{
protected:
DECLARE_DYNCREATE(CWMPPlayer4)
public:
CLSID const& GetClsid()
{
static CLSID const clsid
= { 0x6bf52a52, 0x394a, 0x11d3, { 0xb1, 0x53, 0x0, 0xc0, 0x4f, 0x79, 0xfa, 0xa6 } };
return clsid;
}
/*virtual BOOL Create(LPCTSTR lpszClassName,
LPCTSTR lpszWindowName, DWORD dwStyle,
const RECT& rect,
CWnd* pParentWnd, UINT nID,
CCreateContext* pContext = NULL)
{ return CreateControl(GetClsid(), lpszWindowName, dwStyle, rect, pParentWnd, nID); }*/
BOOL Create(LPCTSTR lpszWindowName, DWORD dwStyle,
const RECT& rect, CWnd* pParentWnd, UINT nID,
CFile* pPersist = NULL, BOOL bStorage = FALSE,
BSTR bstrLicKey = NULL)
{ return CreateControl(GetClsid(), lpszWindowName, dwStyle, rect, pParentWnd, nID,
pPersist, bStorage, bstrLicKey); }
// Attributes
public:
// Operations
public:
void close();
CString GetUrl();
void SetUrl(LPCTSTR lpszNewValue);
long GetOpenState();
long GetPlayState();
CWMPControls GetControls();
CWMPSettings GetSettings();
CWMPMedia GetCurrentMedia();
void SetCurrentMedia(LPDISPATCH newValue);
CWMPMediaCollection GetMediaCollection();
CWMPPlaylistCollection GetPlaylistCollection();
CString GetVersionInfo();
void launchURL(LPCTSTR bstrURL);
CWMPNetwork GetNetwork();
CWMPPlaylist GetCurrentPlaylist();
void SetCurrentPlaylist(LPDISPATCH newValue);
CWMPCdromCollection GetCdromCollection();
CWMPClosedCaption GetClosedCaption();
BOOL GetIsOnline();
CWMPError GetError();
CString GetStatus();
CWMPDVD GetDvd();
CWMPPlaylist newPlaylist(LPCTSTR bstrName, LPCTSTR bstrURL);
CWMPMedia newMedia(LPCTSTR bstrURL);
BOOL GetEnabled();
void SetEnabled(BOOL bNewValue);
BOOL GetFullScreen();
void SetFullScreen(BOOL bNewValue);
BOOL GetEnableContextMenu();
void SetEnableContextMenu(BOOL bNewValue);
void SetUiMode(LPCTSTR lpszNewValue);
CString GetUiMode();
BOOL GetStretchToFit();
void SetStretchToFit(BOOL bNewValue);
BOOL GetWindowlessVideo();
void SetWindowlessVideo(BOOL bNewValue);
BOOL GetIsRemote();
CWMPPlayerApplication GetPlayerApplication();
void openPlayer(LPCTSTR bstrURL);
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPPLAYER4_H__A318AE12_803B_4EED_B586_1395637CDD35__INCLUDED_)

39
plugins/wmpa/wmpplayerapplication.cpp
View File

@ -1,39 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpplayerapplication.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPPlayerApplication properties
/////////////////////////////////////////////////////////////////////////////
// CWMPPlayerApplication operations
void CWMPPlayerApplication::switchToPlayerApplication()
{
InvokeHelper(0x44d, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
void CWMPPlayerApplication::switchToControl()
{
InvokeHelper(0x44e, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
BOOL CWMPPlayerApplication::GetPlayerDocked()
{
BOOL result;
InvokeHelper(0x44f, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
BOOL CWMPPlayerApplication::GetHasDisplay()
{
BOOL result;
InvokeHelper(0x450, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}

36
plugins/wmpa/wmpplayerapplication.h
View File

@ -1,36 +0,0 @@
#if !defined(AFX_WMPPLAYERAPPLICATION_H__A69CB85C_22A1_4A02_979D_3FFB61135553__INCLUDED_)
#define AFX_WMPPLAYERAPPLICATION_H__A69CB85C_22A1_4A02_979D_3FFB61135553__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
/////////////////////////////////////////////////////////////////////////////
// CWMPPlayerApplication wrapper class
class CWMPPlayerApplication : public COleDispatchDriver
{
public:
CWMPPlayerApplication() {} // Calls COleDispatchDriver default constructor
CWMPPlayerApplication(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPPlayerApplication(const CWMPPlayerApplication& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
void switchToPlayerApplication();
void switchToControl();
BOOL GetPlayerDocked();
BOOL GetHasDisplay();
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPPLAYERAPPLICATION_H__A69CB85C_22A1_4A02_979D_3FFB61135553__INCLUDED_)

132
plugins/wmpa/wmpplaylist.cpp
View File

@ -1,132 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpplaylist.h"
// Dispatch interfaces referenced by this interface
#include "WMPMedia.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPPlaylist properties
/////////////////////////////////////////////////////////////////////////////
// CWMPPlaylist operations
long CWMPPlaylist::GetCount()
{
long result;
InvokeHelper(0xc9, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
CString CWMPPlaylist::GetName()
{
CString result;
InvokeHelper(0xca, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPPlaylist::SetName(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xca, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}
long CWMPPlaylist::GetAttributeCount()
{
long result;
InvokeHelper(0xd2, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
CString CWMPPlaylist::GetAttributeName(long lIndex)
{
CString result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xd3, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, parms,
lIndex);
return result;
}
CWMPMedia CWMPPlaylist::GetItem(long lIndex)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0xd4, DISPATCH_PROPERTYGET, VT_DISPATCH, (void*)&pDispatch, parms,
lIndex);
return CWMPMedia(pDispatch);
}
CString CWMPPlaylist::getItemInfo(LPCTSTR bstrName)
{
CString result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0xcb, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
bstrName);
return result;
}
void CWMPPlaylist::setItemInfo(LPCTSTR bstrName, LPCTSTR bstrValue)
{
static BYTE parms[] =
VTS_BSTR VTS_BSTR;
InvokeHelper(0xcc, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
bstrName, bstrValue);
}
BOOL CWMPPlaylist::GetIsIdentical(LPDISPATCH pIWMPPlaylist)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xd5, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
pIWMPPlaylist);
return result;
}
void CWMPPlaylist::clear()
{
InvokeHelper(0xcd, DISPATCH_METHOD, VT_EMPTY, NULL, NULL);
}
void CWMPPlaylist::insertItem(long lIndex, LPDISPATCH pIWMPMedia)
{
static BYTE parms[] =
VTS_I4 VTS_DISPATCH;
InvokeHelper(0xce, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
lIndex, pIWMPMedia);
}
void CWMPPlaylist::appendItem(LPDISPATCH pIWMPMedia)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xcf, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
pIWMPMedia);
}
void CWMPPlaylist::removeItem(LPDISPATCH pIWMPMedia)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0xd0, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
pIWMPMedia);
}
void CWMPPlaylist::moveItem(long lIndexOld, long lIndexNew)
{
static BYTE parms[] =
VTS_I4 VTS_I4;
InvokeHelper(0xd1, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
lIndexOld, lIndexNew);
}

50
plugins/wmpa/wmpplaylist.h
View File

@ -1,50 +0,0 @@
#if !defined(AFX_WMPPLAYLIST_H__B739DAEE_6828_4128_8A0A_E6750502339C__INCLUDED_)
#define AFX_WMPPLAYLIST_H__B739DAEE_6828_4128_8A0A_E6750502339C__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
// Dispatch interfaces referenced by this interface
class CWMPMedia;
/////////////////////////////////////////////////////////////////////////////
// CWMPPlaylist wrapper class
class CWMPPlaylist : public COleDispatchDriver
{
public:
CWMPPlaylist() {} // Calls COleDispatchDriver default constructor
CWMPPlaylist(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPPlaylist(const CWMPPlaylist& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
long GetCount();
CString GetName();
void SetName(LPCTSTR lpszNewValue);
long GetAttributeCount();
CString GetAttributeName(long lIndex);
CWMPMedia GetItem(long lIndex);
CString getItemInfo(LPCTSTR bstrName);
void setItemInfo(LPCTSTR bstrName, LPCTSTR bstrValue);
BOOL GetIsIdentical(LPDISPATCH pIWMPPlaylist);
void clear();
void insertItem(long lIndex, LPDISPATCH pIWMPMedia);
void appendItem(LPDISPATCH pIWMPMedia);
void removeItem(LPDISPATCH pIWMPMedia);
void moveItem(long lIndexOld, long lIndexNew);
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPPLAYLIST_H__B739DAEE_6828_4128_8A0A_E6750502339C__INCLUDED_)

35
plugins/wmpa/wmpplaylistarray.cpp
View File

@ -1,35 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpplaylistarray.h"
// Dispatch interfaces referenced by this interface
#include "wmpplaylist.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPPlaylistArray properties
/////////////////////////////////////////////////////////////////////////////
// CWMPPlaylistArray operations
long CWMPPlaylistArray::GetCount()
{
long result;
InvokeHelper(0x1f5, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
CWMPPlaylist CWMPPlaylistArray::Item(long lIndex)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x1f6, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
lIndex);
return CWMPPlaylist(pDispatch);
}

38
plugins/wmpa/wmpplaylistarray.h
View File

@ -1,38 +0,0 @@
#if !defined(AFX_WMPPLAYLISTARRAY_H__6368C8A4_18CF_4937_993F_F7FBE512B851__INCLUDED_)
#define AFX_WMPPLAYLISTARRAY_H__6368C8A4_18CF_4937_993F_F7FBE512B851__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
// Dispatch interfaces referenced by this interface
class CWMPPlaylist;
/////////////////////////////////////////////////////////////////////////////
// CWMPPlaylistArray wrapper class
class CWMPPlaylistArray : public COleDispatchDriver
{
public:
CWMPPlaylistArray() {} // Calls COleDispatchDriver default constructor
CWMPPlaylistArray(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPPlaylistArray(const CWMPPlaylistArray& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
long GetCount();
CWMPPlaylist Item(long lIndex);
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPPLAYLISTARRAY_H__6368C8A4_18CF_4937_993F_F7FBE512B851__INCLUDED_)

82
plugins/wmpa/wmpplaylistcollection.cpp
View File

@ -1,82 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpplaylistcollection.h"
// Dispatch interfaces referenced by this interface
#include "wmpplaylist.h"
#include "WMPPlaylistArray.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPPlaylistCollection properties
/////////////////////////////////////////////////////////////////////////////
// CWMPPlaylistCollection operations
CWMPPlaylist CWMPPlaylistCollection::newPlaylist(LPCTSTR bstrName)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x228, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrName);
return CWMPPlaylist(pDispatch);
}
CWMPPlaylistArray CWMPPlaylistCollection::getAll()
{
LPDISPATCH pDispatch;
InvokeHelper(0x229, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, NULL);
return CWMPPlaylistArray(pDispatch);
}
CWMPPlaylistArray CWMPPlaylistCollection::getByName(LPCTSTR bstrName)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x22a, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
bstrName);
return CWMPPlaylistArray(pDispatch);
}
void CWMPPlaylistCollection::remove(LPDISPATCH pItem)
{
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x22c, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
pItem);
}
void CWMPPlaylistCollection::setDeleted(LPDISPATCH pItem, BOOL varfIsDeleted)
{
static BYTE parms[] =
VTS_DISPATCH VTS_BOOL;
InvokeHelper(0x230, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
pItem, varfIsDeleted);
}
BOOL CWMPPlaylistCollection::isDeleted(LPDISPATCH pItem)
{
BOOL result;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x231, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
pItem);
return result;
}
CWMPPlaylist CWMPPlaylistCollection::importPlaylist(LPDISPATCH pItem)
{
LPDISPATCH pDispatch;
static BYTE parms[] =
VTS_DISPATCH;
InvokeHelper(0x232, DISPATCH_METHOD, VT_DISPATCH, (void*)&pDispatch, parms,
pItem);
return CWMPPlaylist(pDispatch);
}

44
plugins/wmpa/wmpplaylistcollection.h
View File

@ -1,44 +0,0 @@
#if !defined(AFX_WMPPLAYLISTCOLLECTION_H__D07F4C6A_4574_4463_8A11_4A5654E38062__INCLUDED_)
#define AFX_WMPPLAYLISTCOLLECTION_H__D07F4C6A_4574_4463_8A11_4A5654E38062__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
// Dispatch interfaces referenced by this interface
class CWMPPlaylist;
class CWMPPlaylistArray;
/////////////////////////////////////////////////////////////////////////////
// CWMPPlaylistCollection wrapper class
class CWMPPlaylistCollection : public COleDispatchDriver
{
public:
CWMPPlaylistCollection() {} // Calls COleDispatchDriver default constructor
CWMPPlaylistCollection(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPPlaylistCollection(const CWMPPlaylistCollection& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
CWMPPlaylist newPlaylist(LPCTSTR bstrName);
CWMPPlaylistArray getAll();
CWMPPlaylistArray getByName(LPCTSTR bstrName);
void remove(LPDISPATCH pItem);
void setDeleted(LPDISPATCH pItem, BOOL varfIsDeleted);
BOOL isDeleted(LPDISPATCH pItem);
CWMPPlaylist importPlaylist(LPDISPATCH pItem);
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPPLAYLISTCOLLECTION_H__D07F4C6A_4574_4463_8A11_4A5654E38062__INCLUDED_)

193
plugins/wmpa/wmpsettings.cpp
View File

@ -1,193 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpsettings.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPSettings properties
/////////////////////////////////////////////////////////////////////////////
// CWMPSettings operations
BOOL CWMPSettings::GetIsAvailable(LPCTSTR bstrItem)
{
BOOL result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x71, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, parms,
bstrItem);
return result;
}
BOOL CWMPSettings::GetAutoStart()
{
BOOL result;
InvokeHelper(0x65, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
void CWMPSettings::SetAutoStart(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x65, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}
CString CWMPSettings::GetBaseURL()
{
CString result;
InvokeHelper(0x6c, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPSettings::SetBaseURL(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6c, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}
CString CWMPSettings::GetDefaultFrame()
{
CString result;
InvokeHelper(0x6d, DISPATCH_PROPERTYGET, VT_BSTR, (void*)&result, NULL);
return result;
}
void CWMPSettings::SetDefaultFrame(LPCTSTR lpszNewValue)
{
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6d, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
lpszNewValue);
}
BOOL CWMPSettings::GetInvokeURLs()
{
BOOL result;
InvokeHelper(0x67, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
void CWMPSettings::SetInvokeURLs(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x67, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}
BOOL CWMPSettings::GetMute()
{
BOOL result;
InvokeHelper(0x68, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
void CWMPSettings::SetMute(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x68, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}
long CWMPSettings::GetPlayCount()
{
long result;
InvokeHelper(0x69, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
void CWMPSettings::SetPlayCount(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x69, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}
double CWMPSettings::GetRate()
{
double result;
InvokeHelper(0x6a, DISPATCH_PROPERTYGET, VT_R8, (void*)&result, NULL);
return result;
}
void CWMPSettings::SetRate(double newValue)
{
static BYTE parms[] =
VTS_R8;
InvokeHelper(0x6a, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
newValue);
}
long CWMPSettings::GetBalance()
{
long result;
InvokeHelper(0x66, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
void CWMPSettings::SetBalance(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x66, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}
long CWMPSettings::GetVolume()
{
long result;
InvokeHelper(0x6b, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
void CWMPSettings::SetVolume(long nNewValue)
{
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x6b, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
nNewValue);
}
BOOL CWMPSettings::getMode(LPCTSTR bstrMode)
{
BOOL result;
static BYTE parms[] =
VTS_BSTR;
InvokeHelper(0x6e, DISPATCH_METHOD, VT_BOOL, (void*)&result, parms,
bstrMode);
return result;
}
void CWMPSettings::setMode(LPCTSTR bstrMode, BOOL varfMode)
{
static BYTE parms[] =
VTS_BSTR VTS_BOOL;
InvokeHelper(0x6f, DISPATCH_METHOD, VT_EMPTY, NULL, parms,
bstrMode, varfMode);
}
BOOL CWMPSettings::GetEnableErrorDialogs()
{
BOOL result;
InvokeHelper(0x70, DISPATCH_PROPERTYGET, VT_BOOL, (void*)&result, NULL);
return result;
}
void CWMPSettings::SetEnableErrorDialogs(BOOL bNewValue)
{
static BYTE parms[] =
VTS_BOOL;
InvokeHelper(0x70, DISPATCH_PROPERTYPUT, VT_EMPTY, NULL, parms,
bNewValue);
}

55
plugins/wmpa/wmpsettings.h
View File

@ -1,55 +0,0 @@
#if !defined(AFX_WMPSETTINGS_H__28D3DCCC_3E9A_48AE_97A9_3C1337309AF4__INCLUDED_)
#define AFX_WMPSETTINGS_H__28D3DCCC_3E9A_48AE_97A9_3C1337309AF4__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
/////////////////////////////////////////////////////////////////////////////
// CWMPSettings wrapper class
class CWMPSettings : public COleDispatchDriver
{
public:
CWMPSettings() {} // Calls COleDispatchDriver default constructor
CWMPSettings(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPSettings(const CWMPSettings& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
BOOL GetIsAvailable(LPCTSTR bstrItem);
BOOL GetAutoStart();
void SetAutoStart(BOOL bNewValue);
CString GetBaseURL();
void SetBaseURL(LPCTSTR lpszNewValue);
CString GetDefaultFrame();
void SetDefaultFrame(LPCTSTR lpszNewValue);
BOOL GetInvokeURLs();
void SetInvokeURLs(BOOL bNewValue);
BOOL GetMute();
void SetMute(BOOL bNewValue);
long GetPlayCount();
void SetPlayCount(long nNewValue);
double GetRate();
void SetRate(double newValue);
long GetBalance();
void SetBalance(long nNewValue);
long GetVolume();
void SetVolume(long nNewValue);
BOOL getMode(LPCTSTR bstrMode);
void setMode(LPCTSTR bstrMode, BOOL varfMode);
BOOL GetEnableErrorDialogs();
void SetEnableErrorDialogs(BOOL bNewValue);
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPSETTINGS_H__28D3DCCC_3E9A_48AE_97A9_3C1337309AF4__INCLUDED_)

32
plugins/wmpa/wmpstringcollection.cpp
View File

@ -1,32 +0,0 @@
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
#include "stdafx.h"
#include "wmpstringcollection.h"
/////////////////////////////////////////////////////////////////////////////
// CWMPStringCollection properties
/////////////////////////////////////////////////////////////////////////////
// CWMPStringCollection operations
long CWMPStringCollection::GetCount()
{
long result;
InvokeHelper(0x191, DISPATCH_PROPERTYGET, VT_I4, (void*)&result, NULL);
return result;
}
CString CWMPStringCollection::Item(long lIndex)
{
CString result;
static BYTE parms[] =
VTS_I4;
InvokeHelper(0x192, DISPATCH_METHOD, VT_BSTR, (void*)&result, parms,
lIndex);
return result;
}

34
plugins/wmpa/wmpstringcollection.h
View File

@ -1,34 +0,0 @@
#if !defined(AFX_WMPSTRINGCOLLECTION_H__782BAE9B_652B_476D_9448_808027B17262__INCLUDED_)
#define AFX_WMPSTRINGCOLLECTION_H__782BAE9B_652B_476D_9448_808027B17262__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// Machine generated IDispatch wrapper class(es) created by Microsoft Visual C++
// NOTE: Do not modify the contents of this file. If this class is regenerated by
// Microsoft Visual C++, your modifications will be overwritten.
/////////////////////////////////////////////////////////////////////////////
// CWMPStringCollection wrapper class
class CWMPStringCollection : public COleDispatchDriver
{
public:
CWMPStringCollection() {} // Calls COleDispatchDriver default constructor
CWMPStringCollection(LPDISPATCH pDispatch) : COleDispatchDriver(pDispatch) {}
CWMPStringCollection(const CWMPStringCollection& dispatchSrc) : COleDispatchDriver(dispatchSrc) {}
// Attributes
public:
// Operations
public:
long GetCount();
CString Item(long lIndex);
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_WMPSTRINGCOLLECTION_H__782BAE9B_652B_476D_9448_808027B17262__INCLUDED_)

1
win32/hexchat.props
View File

@ -90,7 +90,6 @@ copy "$(HexChatBin)hcpython.dll" "$(HexChatRel)\plugins"
copy "$(HexChatBin)hcupd.dll" "$(HexChatRel)\plugins"
copy "$(HexChatBin)hcwinamp.dll" "$(HexChatRel)\plugins"
copy "$(HexChatBin)hcsysinfo.dll" "$(HexChatRel)\plugins"
::copy "$(HexChatBin)hcwmpa.dll" "$(HexChatRel)\plugins"
xcopy /q /s /i "$(HexChatBin)locale" "$(HexChatRel)\share\locale"
xcopy /q /s /i "$(DepsRoot)\share\locale" "$(HexChatRel)\share\locale"
</HexChatCopy>

6
win32/hexchat.sln
View File

@ -52,8 +52,6 @@ Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "sysinfo", "..\plugins\sysin
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "hextray", "..\plugins\hextray\hextray.vcxproj", "{3024CF36-85E5-4E00-9608-7002E2C7EF14}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "wmpa", "..\plugins\wmpa\wmpa.vcxproj", "{E7F4DB0A-510D-41EF-B284-6E1DE1CC450D}"
EndProject
Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "release", "release", "{0FD996A7-464F-4981-8380-3DCA3A244A13}"
EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "nls", "nls\nls.vcxproj", "{B10A2C41-344C-43E0-A32D-B9587C198D8B}"
@ -61,7 +59,6 @@ EndProject
Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "copy", "copy\copy.vcxproj", "{C9B735E4-75BC-45AC-A5E3-39A6D076F912}"
ProjectSection(ProjectDependencies) = postProject
{19C52A0A-A790-409E-A28A-9745FF990F5C} = {19C52A0A-A790-409E-A28A-9745FF990F5C}
{E7F4DB0A-510D-41EF-B284-6E1DE1CC450D} = {E7F4DB0A-510D-41EF-B284-6E1DE1CC450D}
{4980AF24-9D42-427D-A8E6-0DF3B97C455D} = {4980AF24-9D42-427D-A8E6-0DF3B97C455D}
{3024CF36-85E5-4E00-9608-7002E2C7EF14} = {3024CF36-85E5-4E00-9608-7002E2C7EF14}
{17E4BE39-76F7-4A06-AD21-EFD0C5091F76} = {17E4BE39-76F7-4A06-AD21-EFD0C5091F76}
@ -158,8 +155,6 @@ Global
{6C0CA980-97C5-427A-BE61-5BCECAFABBDA}.Release|x64.Build.0 = Release|x64
{3024CF36-85E5-4E00-9608-7002E2C7EF14}.Release|Win32.ActiveCfg = Release|Win32
{3024CF36-85E5-4E00-9608-7002E2C7EF14}.Release|x64.ActiveCfg = Release|x64
{E7F4DB0A-510D-41EF-B284-6E1DE1CC450D}.Release|Win32.ActiveCfg = Release|Win32
{E7F4DB0A-510D-41EF-B284-6E1DE1CC450D}.Release|x64.ActiveCfg = Release|x64
{B10A2C41-344C-43E0-A32D-B9587C198D8B}.Release|Win32.ActiveCfg = Release|Win32
{B10A2C41-344C-43E0-A32D-B9587C198D8B}.Release|Win32.Build.0 = Release|Win32
{B10A2C41-344C-43E0-A32D-B9587C198D8B}.Release|x64.ActiveCfg = Release|x64
@ -206,7 +201,6 @@ Global
{E78C0D9A-798E-4BF6-B0CC-6FECB8CA2FCE} = {561126F4-FA18-45FC-A2BF-8F858F161D6D}
{6C0CA980-97C5-427A-BE61-5BCECAFABBDA} = {561126F4-FA18-45FC-A2BF-8F858F161D6D}
{3024CF36-85E5-4E00-9608-7002E2C7EF14} = {561126F4-FA18-45FC-A2BF-8F858F161D6D}
{E7F4DB0A-510D-41EF-B284-6E1DE1CC450D} = {561126F4-FA18-45FC-A2BF-8F858F161D6D}
{19C52A0A-A790-409E-A28A-9745FF990F5C} = {D237DA6B-BD5F-46C0-8BEA-50E9A1340240}
{D90BC3E3-1341-4849-9354-5F40489D39D1} = {D237DA6B-BD5F-46C0-8BEA-50E9A1340240}
{B10A2C41-344C-43E0-A32D-B9587C198D8B} = {0FD996A7-464F-4981-8380-3DCA3A244A13}

2
win32/installer/hexchat-x64.skel.iss
View File

@ -45,7 +45,6 @@ Name: "plugins\mpcinfo"; Description: "mpcInfo"; Types: custom; Flags: disableno
Name: "plugins\sysinfo"; Description: "SysInfo"; Types: custom; Flags: disablenouninstallwarning
Name: "plugins\upd"; Description: "Update Checker"; Types: normal custom; Flags: disablenouninstallwarning
Name: "plugins\winamp"; Description: "Winamp"; Types: custom; Flags: disablenouninstallwarning
;Name: "plugins\wmpa"; Description: "Windows Media Player Announcer"; Types: custom; Flags: disablenouninstallwarning
Name: "langs"; Description: "Language Interfaces"; Types: custom; Flags: disablenouninstallwarning
Name: "langs\perl"; Description: "Perl (requires Perl 5.18)"; Types: custom; Flags: disablenouninstallwarning
Name: "langs\python"; Description: "Python (requires Python 2.7)"; Types: custom; Flags: disablenouninstallwarning
@ -144,7 +143,6 @@ Source: "plugins\hcupd.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Com
Source: "plugins\hcwinamp.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Components: plugins\winamp
Source: "etc\system.png"; DestDir: "{app}\etc"; Flags: ignoreversion; Components: plugins\sysinfo
Source: "plugins\hcsysinfo.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Components: plugins\sysinfo
;Source: "plugins\hcwmpa.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Components: plugins\wmpa
Source: "plugins\hcpython.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Components: langs\python
Source: "plugins\hcperl.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Components: langs\perl

2
win32/installer/hexchat-x86.skel.iss
View File

@ -44,7 +44,6 @@ Name: "plugins\mpcinfo"; Description: "mpcInfo"; Types: custom; Flags: disableno
Name: "plugins\sysinfo"; Description: "SysInfo"; Types: custom; Flags: disablenouninstallwarning
Name: "plugins\upd"; Description: "Update Checker"; Types: normal custom; Flags: disablenouninstallwarning
Name: "plugins\winamp"; Description: "Winamp"; Types: custom; Flags: disablenouninstallwarning
;Name: "plugins\wmpa"; Description: "Windows Media Player Announcer"; Types: custom; Flags: disablenouninstallwarning
Name: "langs"; Description: "Language Interfaces"; Types: custom; Flags: disablenouninstallwarning
Name: "langs\perl"; Description: "Perl (requires Perl 5.18)"; Types: custom; Flags: disablenouninstallwarning
Name: "langs\python"; Description: "Python (requires Python 2.7)"; Types: custom; Flags: disablenouninstallwarning
@ -143,7 +142,6 @@ Source: "plugins\hcupd.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Com
Source: "plugins\hcwinamp.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Components: plugins\winamp
Source: "etc\system.png"; DestDir: "{app}\etc"; Flags: ignoreversion; Components: plugins\sysinfo
Source: "plugins\hcsysinfo.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Components: plugins\sysinfo
;Source: "plugins\hcwmpa.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Components: plugins\wmpa
Source: "plugins\hcpython.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Components: langs\python
Source: "plugins\hcperl.dll"; DestDir: "{app}\plugins"; Flags: ignoreversion; Components: langs\perl