610 lines
12 KiB
C++
610 lines
12 KiB
C++
/*
|
|
** Command & Conquer Red Alert(tm)
|
|
** Copyright 2025 Electronic Arts Inc.
|
|
**
|
|
** This program is free software: you can redistribute it and/or modify
|
|
** it under the terms of the GNU General Public License as published by
|
|
** the Free Software Foundation, either version 3 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** This program is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License
|
|
** along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/****************************************************************************
|
|
*
|
|
* FILE
|
|
* MpgSet.cpp
|
|
*
|
|
* DESCRIPTION
|
|
* Mpeg movie settings manager
|
|
*
|
|
* PROGRAMMER
|
|
* Denzil E. Long, Jr.
|
|
*
|
|
* DATE
|
|
* June 30, 1998
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include "function.h"
|
|
|
|
#ifdef DVD
|
|
#include "mpgset.h"
|
|
|
|
#ifdef MCIMPEG
|
|
bool EnumMCI(MCIDevice* desc, void* context);
|
|
#endif
|
|
|
|
/****************************************************************************
|
|
*
|
|
* NAME
|
|
* MPGSettings(DeviceName)
|
|
*
|
|
* DESCRIPTION
|
|
* Default constructor
|
|
*
|
|
* INPUTS
|
|
* DeviceName - Initial device to use for MPG playback (NULL = DXMedia)
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
****************************************************************************/
|
|
|
|
MPGSettings::MPGSettings(const char* deviceName)
|
|
: mDeviceName(NULL)
|
|
{
|
|
SetDeviceName(deviceName);
|
|
|
|
#ifdef MCIMPEG
|
|
int count = mMCI.GetDeviceCount();
|
|
|
|
mMCIDevices = NULL;
|
|
mCount = 0;
|
|
|
|
if (count)
|
|
{
|
|
mMCIDevices = new MCIDevice[count];
|
|
|
|
if (mMCIDevices)
|
|
{
|
|
mMCI.EnumerateDevices(EnumMCI, this);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
MPGSettings::MPGSettings(FileClass& file)
|
|
: mDeviceName(NULL)
|
|
{
|
|
INIClass ini;
|
|
char buffer[256];
|
|
char* device = NULL;
|
|
|
|
#ifdef MCIMPEG
|
|
int count = mMCI.GetDeviceCount();
|
|
|
|
mMCIDevices = NULL;
|
|
mCount = 0;
|
|
|
|
// Enumerate all the MCI devices that can play a movie
|
|
if (count)
|
|
{
|
|
mMCIDevices = new MCIDevice[count];
|
|
|
|
if (mMCIDevices)
|
|
{
|
|
mMCI.EnumerateDevices(EnumMCI, this);
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
// Retrieve the user specified device from the config file
|
|
buffer[0] = '\0';
|
|
|
|
if (ini.Load(file))
|
|
{
|
|
ini.Get_String("MovieSettings", "Device", "Default", buffer, sizeof(buffer));
|
|
}
|
|
|
|
// If there is a specification in the config and it isn't the default
|
|
if ((strlen(buffer) != 0) && (stricmp(buffer, "Default") != 0))
|
|
{
|
|
#ifdef MCIMPEG
|
|
// Search for selection
|
|
for (int i = 0; i < mCount; i++)
|
|
{
|
|
if (stricmp(buffer, mMCIDevices[i].name) == 0)
|
|
{
|
|
device = mMCIDevices[i].name;
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
SetDeviceName(device);
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* NAME
|
|
* ~MPGSettings
|
|
*
|
|
* DESCRIPTION
|
|
* Destructor
|
|
*
|
|
* INPUTS
|
|
* NONE
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
****************************************************************************/
|
|
|
|
MPGSettings::~MPGSettings(void)
|
|
{
|
|
if (mDeviceName)
|
|
free(mDeviceName);
|
|
|
|
#ifdef MCIMPEG
|
|
if (mMCIDevices)
|
|
delete[] mMCIDevices;
|
|
#endif
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* NAME
|
|
* SetDeviceName(DeviceName)
|
|
*
|
|
* DESCRIPTION
|
|
* Change current device used for mpeg playback
|
|
*
|
|
* INPUTS
|
|
* DeviceName - Device name type (IE: mpegvideo)
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
****************************************************************************/
|
|
|
|
void MPGSettings::SetDeviceName(const char* deviceName)
|
|
{
|
|
if (mDeviceName)
|
|
free(mDeviceName);
|
|
|
|
mDeviceName = NULL;
|
|
|
|
if (deviceName)
|
|
mDeviceName = strdup(deviceName);
|
|
}
|
|
|
|
|
|
bool MPGSettings::Save(FileClass& file)
|
|
{
|
|
INIClass ini;
|
|
|
|
if (ini.Load(file))
|
|
{
|
|
const char* device = GetDeviceName();
|
|
|
|
if (device)
|
|
{
|
|
ini.Put_String("MovieSettings", "Device", device);
|
|
}
|
|
else
|
|
{
|
|
ini.Put_String("MovieSettings", "Device", "Default");
|
|
}
|
|
|
|
ini.Save(file);
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
*
|
|
* NAME
|
|
* Dialog()
|
|
*
|
|
* DESCRIPTION
|
|
* Mpeg playback settings dialog
|
|
*
|
|
* INPUTS
|
|
* NONE
|
|
*
|
|
* RESULT
|
|
* NONE
|
|
*
|
|
****************************************************************************/
|
|
|
|
void MPGSettings::Dialog(void)
|
|
{
|
|
// Dialog & button dimensions
|
|
int d_dialog_w = 200 *RESFACTOR;
|
|
int d_dialog_h = 100 *RESFACTOR;
|
|
int d_dialog_x = (((320*RESFACTOR) - d_dialog_w) / 2);
|
|
int d_dialog_y = 70 * RESFACTOR;
|
|
int d_dialog_cx = d_dialog_x + (d_dialog_w / 2);
|
|
|
|
int d_txt6_h = 7 *RESFACTOR;
|
|
int d_margin = 7 *RESFACTOR;
|
|
|
|
int d_okay_w = 40 *RESFACTOR;
|
|
int d_okay_h = 9 *RESFACTOR;
|
|
int d_okay_x = d_dialog_x + d_margin + 20;
|
|
int d_okay_y = ((d_dialog_y + d_dialog_h) - (d_okay_h + 20));
|
|
|
|
int d_test_w = 40 *RESFACTOR;
|
|
int d_test_h = 9 *RESFACTOR;
|
|
int d_test_x = (d_dialog_cx - (d_test_w / 2));
|
|
int d_test_y = ((d_dialog_y + d_dialog_h) - (d_test_h + 20));
|
|
|
|
int d_cancel_w = 40 *RESFACTOR;
|
|
int d_cancel_h = 9 *RESFACTOR;
|
|
int d_cancel_x = ((d_dialog_x + d_dialog_w) - (d_cancel_w + d_margin + 20));
|
|
int d_cancel_y = ((d_dialog_y + d_dialog_h) - (d_cancel_h + 20));
|
|
|
|
int d_method_w = 165 * RESFACTOR;
|
|
int d_method_h = 50 * RESFACTOR;
|
|
int d_method_x = (d_dialog_cx - (d_method_w / 2));
|
|
int d_method_y = (d_dialog_y + 40);
|
|
|
|
// Button enumerations:
|
|
enum
|
|
{
|
|
BUTTON_OKAY = 100,
|
|
BUTTON_TEST,
|
|
BUTTON_CANCEL,
|
|
BUTTON_METHOD,
|
|
NUM_OF_BUTTONS = 4,
|
|
};
|
|
|
|
int num_of_buttons = NUM_OF_BUTTONS;
|
|
|
|
// Redraw values: in order from "top" to "bottom" layer of the dialog
|
|
typedef enum
|
|
{
|
|
REDRAW_NONE = 0,
|
|
REDRAW_BUTTONS, // includes map interior & coord values
|
|
REDRAW_BACKGROUND, // includes box, map bord, key, coord labels, btns
|
|
REDRAW_ALL = REDRAW_BACKGROUND
|
|
} RedrawType;
|
|
|
|
// Dialog variables:
|
|
KeyNumType input; // input from user
|
|
bool process; // loop while true
|
|
RedrawType display; // true = re-draw everything
|
|
int selection;
|
|
bool pressed;
|
|
int curbutton;
|
|
TextButtonClass * buttons[NUM_OF_BUTTONS];
|
|
int i;
|
|
char* origDevice = NULL;
|
|
|
|
// Buttons
|
|
ControlClass * commands = NULL; // the button list
|
|
|
|
TextButtonClass okaybtn(BUTTON_OKAY, TXT_OK, TPF_BUTTON,
|
|
d_okay_x, d_okay_y, d_okay_w, d_okay_h);
|
|
|
|
TextButtonClass testbtn(BUTTON_TEST, "Test", TPF_BUTTON,
|
|
d_test_x, d_test_y, d_test_w, d_test_h);
|
|
|
|
TextButtonClass cancelbtn(BUTTON_CANCEL, TXT_CANCEL, TPF_BUTTON,
|
|
d_cancel_x, d_cancel_y, d_cancel_w, d_cancel_h);
|
|
|
|
ListClass method(BUTTON_METHOD, d_method_x, d_method_y, d_method_w,
|
|
d_method_h, TPF_TEXT, MFCD::Retrieve("BTN-UP.SHP"), MFCD::Retrieve("BTN-DN.SHP"));
|
|
|
|
// Initialize
|
|
Set_Logic_Page(SeenBuff);
|
|
|
|
// Create the list
|
|
commands = &okaybtn;
|
|
testbtn.Add_Tail(*commands);
|
|
cancelbtn.Add_Tail(*commands);
|
|
method.Add_Tail(*commands);
|
|
|
|
// Fill array of button ptrs
|
|
curbutton = 0;
|
|
buttons[0] = &okaybtn;
|
|
buttons[1] = &testbtn;
|
|
buttons[2] = &cancelbtn;
|
|
buttons[curbutton]->Turn_On();
|
|
|
|
Keyboard->Clear();
|
|
|
|
Fancy_Text_Print(TXT_NONE, 0, 0, GadgetClass::Get_Color_Scheme(), TBLACK,
|
|
TPF_CENTER | TPF_TEXT);
|
|
|
|
// Add device to device control
|
|
method.Add_Item("DirectX Media (Default)");
|
|
|
|
#ifdef MCIMPEG
|
|
for (i = 0; i < mCount; i++)
|
|
{
|
|
if (mMCIDevices[i].description != NULL)
|
|
{
|
|
method.Add_Item(mMCIDevices[i].description);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
method.Set_Selected_Index(0);
|
|
|
|
#ifdef MCIMPEG
|
|
// Search for current selection
|
|
if (GetDeviceName())
|
|
{
|
|
for (i = 0; i < mCount; i++)
|
|
{
|
|
if (stricmp(GetDeviceName(), mMCIDevices[i].name) == 0)
|
|
{
|
|
method.Set_Selected_Index(i + 1);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Save original device selection
|
|
if (GetDeviceName())
|
|
origDevice = strdup(GetDeviceName());
|
|
|
|
//------------------------------------------------------------------------
|
|
// Main Processing Loop
|
|
//------------------------------------------------------------------------
|
|
display = REDRAW_ALL;
|
|
process = true;
|
|
pressed = false;
|
|
|
|
while (process)
|
|
{
|
|
#ifdef WIN32
|
|
/*
|
|
** If we have just received input focus again after running in the background then
|
|
** we need to redraw.
|
|
*/
|
|
if (AllSurfaces.SurfacesRestored)
|
|
{
|
|
AllSurfaces.SurfacesRestored=FALSE;
|
|
display = REDRAW_ALL;
|
|
}
|
|
#endif
|
|
|
|
// Invoke game callback
|
|
Call_Back();
|
|
|
|
// Refresh display if needed
|
|
if (display)
|
|
{
|
|
Hide_Mouse();
|
|
|
|
if (display >= REDRAW_BACKGROUND)
|
|
{
|
|
// Refresh the backdrop
|
|
Load_Title_Page(true);
|
|
CCPalette.Set();
|
|
|
|
// Draw the background
|
|
Dialog_Box(d_dialog_x, d_dialog_y, d_dialog_w, d_dialog_h);
|
|
Draw_Caption("Movie Settings", d_dialog_x, d_dialog_y, d_dialog_w);
|
|
}
|
|
|
|
// Redraw buttons
|
|
if (display >= REDRAW_BUTTONS)
|
|
commands->Flag_List_To_Redraw();
|
|
|
|
Show_Mouse();
|
|
display = REDRAW_NONE;
|
|
}
|
|
|
|
// Get user input
|
|
input = commands->Input();
|
|
|
|
// Process input
|
|
switch (input)
|
|
{
|
|
case (BUTTON_OKAY | KN_BUTTON):
|
|
selection = BUTTON_OKAY;
|
|
pressed = true;
|
|
break;
|
|
|
|
case (BUTTON_TEST | KN_BUTTON):
|
|
selection = BUTTON_TEST;
|
|
pressed = true;
|
|
break;
|
|
|
|
case (KN_ESC):
|
|
case (BUTTON_CANCEL | KN_BUTTON):
|
|
selection = BUTTON_CANCEL;
|
|
pressed = true;
|
|
break;
|
|
|
|
case KN_UP:
|
|
buttons[curbutton]->Turn_Off();
|
|
buttons[curbutton]->Flag_To_Redraw();
|
|
curbutton--;
|
|
|
|
if (curbutton < 0)
|
|
curbutton = (num_of_buttons - 1);
|
|
|
|
buttons[curbutton]->Turn_On();
|
|
buttons[curbutton]->Flag_To_Redraw();
|
|
break;
|
|
|
|
case KN_DOWN:
|
|
buttons[curbutton]->Turn_Off();
|
|
buttons[curbutton]->Flag_To_Redraw();
|
|
curbutton++;
|
|
|
|
if (curbutton > (num_of_buttons - 1))
|
|
curbutton = 0;
|
|
|
|
buttons[curbutton]->Turn_On();
|
|
buttons[curbutton]->Flag_To_Redraw();
|
|
break;
|
|
|
|
case KN_RETURN:
|
|
selection = curbutton + BUTTON_OKAY;
|
|
pressed = true;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (pressed)
|
|
{
|
|
// to make sure the selection is correct in case they used the mouse
|
|
buttons[curbutton]->Turn_Off();
|
|
buttons[curbutton]->Flag_To_Redraw();
|
|
|
|
curbutton = selection - BUTTON_OKAY;
|
|
buttons[curbutton]->Turn_On();
|
|
buttons[curbutton]->IsPressed = true;
|
|
buttons[curbutton]->Draw_Me(true);
|
|
|
|
switch (selection)
|
|
{
|
|
case (BUTTON_TEST):
|
|
buttons[curbutton]->IsPressed = false;
|
|
|
|
if (method.Current_Index() == 0)
|
|
{
|
|
SetDeviceName(NULL);
|
|
}
|
|
else
|
|
{
|
|
i = method.Current_Index();
|
|
#ifdef MCIMPEG
|
|
SetDeviceName(mMCIDevices[i - 1].name);
|
|
#endif
|
|
}
|
|
|
|
Theme.Fade_Out();
|
|
Hide_Mouse();
|
|
VisiblePage.Clear();
|
|
PlayMpegMovie("acrop");
|
|
Keyboard->Clear();
|
|
Show_Mouse();
|
|
Theme.Queue_Song(THEME_CRUS);
|
|
display = REDRAW_ALL;
|
|
|
|
buttons[curbutton]->Turn_Off();
|
|
buttons[curbutton]->Flag_To_Redraw();
|
|
buttons[0]->Turn_On();
|
|
curbutton = 0;
|
|
break;
|
|
|
|
case (BUTTON_OKAY):
|
|
process = false;
|
|
|
|
if (method.Current_Index() == 0)
|
|
{
|
|
SetDeviceName(NULL);
|
|
}
|
|
else
|
|
{
|
|
i = method.Current_Index();
|
|
#ifdef MCIMPEG
|
|
SetDeviceName(mMCIDevices[i - 1].name);
|
|
#endif
|
|
}
|
|
|
|
{
|
|
RawFileClass file(CONFIG_FILE_NAME);
|
|
Save(file);
|
|
}
|
|
break;
|
|
|
|
case (BUTTON_CANCEL):
|
|
process = false;
|
|
SetDeviceName(origDevice);
|
|
break;
|
|
}
|
|
|
|
pressed = false;
|
|
}
|
|
}
|
|
|
|
if (origDevice)
|
|
free(origDevice);
|
|
}
|
|
|
|
|
|
#ifdef MCIMPEG
|
|
/****************************************************************************
|
|
*
|
|
* NAME
|
|
* EnumMCI(DeviceDesc, Context)
|
|
*
|
|
* DESCRIPTION
|
|
* MCI device enumeration callback
|
|
*
|
|
* INPUTS
|
|
* DeviceDesc - MCI device description
|
|
* Context - User defined context variable
|
|
*
|
|
* RESULT
|
|
* Continue - Continue with next device flag
|
|
*
|
|
****************************************************************************/
|
|
|
|
bool EnumMCI(MCIDevice* desc, void* context)
|
|
{
|
|
MPGSettings* mpgset = (MPGSettings*)context;
|
|
|
|
// Digital video device type?
|
|
if (desc->type == MCI_DEVTYPE_DIGITAL_VIDEO)
|
|
{
|
|
if (MciMovie)
|
|
{
|
|
CCFileClass file;
|
|
const char* filename;
|
|
|
|
filename = file.Set_Name("movies\\acrop.mpg");
|
|
|
|
if (!file.Is_Available())
|
|
{
|
|
char buffer[256];
|
|
sprintf(buffer, "Couldn't test MCI device %s\n", desc->name);
|
|
VisiblePage.Clear();
|
|
GamePalette.Set();
|
|
Show_Mouse();
|
|
WWMessageBox().Process(buffer);
|
|
Hide_Mouse();
|
|
VisiblePage.Clear();
|
|
return true;
|
|
}
|
|
|
|
if (MciMovie->Open(filename, desc->name))
|
|
{
|
|
MciMovie->Close();
|
|
memcpy((void*)&mpgset->mMCIDevices[mpgset->mCount], (void*)desc,
|
|
sizeof(MCIDevice));
|
|
mpgset->mCount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
#endif
|
|
#endif
|