//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Crea una superficie compleja y le asocia una superficie para que
// sea backbuffer. En caso de que todo vaya bien, se intentara
// crear un objeto para controla el gamma.
// Parametros:
// - poDXDraw: Instancia a clase DXDraw con objeto DirectDraw.
// - ubNumBackBuffers: Numero de buffers en superficie compleja.
// - poBackBuffer: Puntero a superfice que hara de backbuffer y sera
// de tipo ATTACHED, acabando asociada a la compleja creada.
// - wMem: Tipo de memoria en donde crear la superficie compleja.
// - bD3DSurface: True si la superficie se va a utilizar con un device
// 3D y false en caso contrario. Por defecto vale false.
// Devuelve:
// - true: Todo fue bien.
// - false: Existieron problemas
// Notas:
// - Este metodo es ideal para crear, rapidamente, un sistema de
// intercambio con superficie compleja. Simplemente realiza las
// dos llamadas que hay que efectuar por separado, aqui dentro.
// - En caso de que ya haya creada una superficie, la liberara.
//////////////////////////////////////////////////////////////////////
bool DXDDSurfaceScreen::CreateComplex(const DXDraw* const poDXDraw,
const byte ubNumBackBuffers,
DXDDSurfaceBack* const poBackBuffer,
const DXDDDefs::DXDDMemType& wMem,
const bool bD3DSurface)
{
// SOLO si existe puntero a la supercie pasada
DXASSERT(NULL != poBackBuffer);
// SOLO si superficie pasada no esta creada
DXASSERT(DXDDDefs::SURFACETYPE_NOCREATED == poBackBuffer->GetType());
if (CreateComplex(poDXDraw, ubNumBackBuffers, wMem, bD3DSurface)) {
// Se ha creado la superficie compleja
if(AttachToComplex(poBackBuffer)) {
// Se logro asociar el backbuffer
// Se guarda la referencia al BackBuffer
m_poBackBuffer = poBackBuffer;
// Todo correcto
return true;
}
}
// Existieron problemas
return false;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Crea una superficie primaria simple.
// Parametros:
// - poDXDraw: Puntero a instancia DXDraw.
// - wMem: Memoria en donde crear la superficie primaria
// - bD3DSurface: True si la superficie se va a utilizar con un device
// 3D y false en caso contrario. Por defecto vale false.
// Devuelve:
// - true: Todo ha ido correctamente.
// - false: Ha ocurrido algun error.
// Notas:
// - Este metodo crea una superficie primaria simple. Una superficie
// primaria simple NO puede tener asociados BackBuffer, pero si
// puede realizar la operacion de Flip.
// - Este tipo de superficies primarias NO son recomendadas
// para el trabajo a ventana completa
// - Este tipo de superficies primarias son las UNICAS que se pueden
// utilizar en modo ventana.
//////////////////////////////////////////////////////////////////////
bool DXDDSurfaceScreen::CreatePrimary(const DXDraw* const poDXDraw,
const DXDDDefs::DXDDMemType& wMem,
const bool bD3DSurface)
{
// SOLO si hay instancia a DXDraw
DXASSERT(NULL != poDXDraw);
// SOLO si la superficie actual no es ATTACH
DXASSERT(DXDDDefs::SURFACETYPE_ATTACHED != m_SurfaceType);
DDSURFACEDESC2 desc; // Estructura de definicion de surface
DWORD dwFlagMem; // Flag con el tipo de memoria
// Inicializaciones
memset(&desc, 0, sizeof(desc));
desc.dwSize = sizeof(desc);
// Si la surface esta ocupada la libera
if (m_pDDSurface != NULL) {
Clean();
Init();
}
// Establece flags dependiendo del tipo de memoria
switch(wMem)
{
case DXDDDefs::VIDEOMEM: // Memoria de video
dwFlagMem = DDSCAPS_VIDEOMEMORY;
break;
case DXDDDefs::SYSTEMMEM: // Memoria de sistema
dwFlagMem = DDSCAPS_SYSTEMMEMORY;
break;
}
// Establece la descripcion para una superficie
// primaria simple.
desc.dwFlags = DDSD_CAPS;
desc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | dwFlagMem;
// ¿Se va a utilizar con un device 3D?
if (bD3DSurface) { desc.ddsCaps.dwCaps |= DDSCAPS_3DDEVICE; }
// Procede a crear la superficie
m_CodeResult = poDXDraw->GetObj()->CreateSurface(&desc,
&m_pDDSurface,
NULL);
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDDError::DXDDErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// Obtiene datos sobre la superficie creada
m_dwWidth = poDXDraw->GetDisplayWidth();
m_dwHeight = poDXDraw->GetDisplayHeight();
m_SurfaceType = DXDDDefs::SURFACETYPE_PRIMARY;
SetPixelFormat();
// Todo correcto
return true;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Configura los altavoces del usuario segun el tipo y
// su geometria.
// Parametros:
// - dwType: Tipo de altavoces entre:
// * DSSPEAKER_HEADPHONE <auriculares>
// * DSSPEAKER_MONO <sistema mono>
// * DSSPEAKER_QUAD <sistema cuadrafonico>
// * DSSPEAKER_STEREO <sistema estereo>
// * DSSPEAKER_SURROUND <sistema doble surround>
// - dwGeometry: Geometria de los altavoces con respecto al usuario:
// * DSSPEAKER_GEOMETRY_MIN <5 grados>
// * DSSPEAKER_GEOMETRY_NARROW <10 grados>
// * DSSPEAKER_GEOMETRY_WIDE <20 grados>
// * DSSPEAKER_GEOMETRY_MAX <180 grados>
// Devuelve:
// true: Si se han configurado altavoces con exito.
// false: Si no se ha podido realizar la configuracion.
// Notas:
// - La informacion de la geometria solo tiene sentido cuando se
// habla de altavoces stereo en cuyo caso tiene valor por defecto
// a DSSPEAKER_GEOMETRY_WIDE.
// - En el caso de que no se haya creado objeto DirectSound el
// metodo retorna sin hacer nada.
//////////////////////////////////////////////////////////////////////
bool DXSound::SetSpeakers(const dword dwType,
const dword dwGeometry)
{
// SOLO si hay objeto DirectSound
DXASSERT(m_lpDSObj != NULL);
// Efectua configuracion de altavoces
if (dwType != DSSPEAKER_STEREO) {
// Configuracion no estereo
m_CodeResult = m_lpDSObj->SetSpeakerConfig(dwType);
}
else {
// Configuracion estereo; hay que combinar flags
m_CodeResult = m_lpDSObj->SetSpeakerConfig(DSSPEAKER_COMBINED(dwType, dwGeometry));
}
// Comprueba resultado operacion
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// Todo correcto
return true;
}
void CDxMonthPicker::ScrollLeft(int nMonthCount)
{
int nYear = m_dtFirstMonth.GetYear();
int nMonth = m_dtFirstMonth.GetMonth();
if (nYear < 100 || (nYear == 100 && nMonth <= 2))
return;
int nYearNew = nYear - nMonthCount / 12;
int nMonthNew = nMonth - nMonthCount % 12;
if (nMonthNew < 1)
{
nMonthNew += 12;
nYearNew--;
}
DXASSERT(nMonthNew >= 1 && nMonthNew <= 12);
if (m_dtMinRange.GetStatus() == COleDateTime::valid)
{
if (nYearNew < m_dtMinRange.GetYear())
{
nYearNew = m_dtMinRange.GetYear();
nMonthNew = m_dtMinRange.GetMonth();
}
if (m_dtMinRange.GetYear() == nYearNew)
{
if (nMonthNew < m_dtMinRange.GetMonth())
nMonthNew = m_dtMinRange.GetMonth();
}
}
m_dtFirstMonth.SetDate(nYearNew, nMonthNew, 1);
Populate();
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Detiene el sonido que se este reproduciendo.
// Parametros:
// - bInitPlayPos: Indica si hay que parar y poner al comienzo el
// cursor de reproduccion. Por defecto vale true, con lo que se
// llevara al comienzo el cursor si no se recibe otro parametro.
// Devuelve:
// - true: Si se detiene el sonido o el sonido.
// - false: Existe algun tipo de problema.
// Notas:
// - Aunque el buffer se encuentre sin ser reproducido, al llamar a
// stop se devolvera true si todo sale bien.
//////////////////////////////////////////////////////////////////////
bool DXDSWAVSound::Stop(const bool bInitPlayPos)
{
// SOLO si hay buffer secundario
DXASSERT(m_lpDSBuffer != NULL);
// Para la reproduccion
m_CodeResult = m_lpDSBuffer->Stop();
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// ¿Hay que resituar el cursor?
if (bInitPlayPos) {
// Si; ademas de parar hay que situar el cursor en la pos. inicial
if (!SetPlayPosition()) {
// No se pudo situar el cursor; se establece codigo de error interno
m_CodeResult = S_OK;
m_sLastCode = DXDSBUFFERS_SETPLAYPOSERROR_MSG;
return false;
}
}
// Todo correcto
return true;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Reproduce el sonido almacenado (o asociado) en el buffer secundario.
// Parametros:
// - dwFlags: Modo de reproduccion. Por defecto reproduce una
// sola vez el sonido y acaba. Si recibe DSBPLAY_LOOPING se
// reproducira el sonido continuamente.
// Devuelve:
// - true: Si la operacion se realiza con exito.
// - false: Existe algun problema.
// Notas:
//////////////////////////////////////////////////////////////////////
bool DXDSWAVSound::Play(const dword dwFlags)
{
// SOLO si hay buffer secundario
DXASSERT(m_lpDSBuffer != NULL);
DWORD dwStatus; // Estado del buffer secundario
// Inicializaciones
dwStatus = m_lpDSBuffer->GetStatus(&dwStatus);
// ¿Se ha perdido el buffer?
if (dwStatus & DSBSTATUS_BUFFERLOST) {
// Si; se llama al metodo Restore para recuperarlo
Restore();
}
// Se pone en marcha el sonido
m_CodeResult = m_lpDSBuffer->Play(0, 0, dwFlags);
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// Todo correcto
return true;
}
CString GetLocaleString(LCTYPE LCType, int nMaxLength)
{
CString strResult;
int nResult = ::GetLocaleInfo(LOCALE_USER_DEFAULT, LCType , strResult.GetBufferSetLength(nMaxLength), nMaxLength);
strResult.ReleaseBuffer();
DXASSERT(strResult.GetLength() == nResult - 1);
return strResult;
}
void XTPGetAsSystemTime(const COleDateTime& dateTime, SYSTEMTIME& st)
{
#if _MSC_VER < 1200
UNREFERENCED_PARAMETER(dateTime);
UNREFERENCED_PARAMETER(st);
DXASSERT(FALSE);
#else
dateTime.GetAsSystemTime(st);
#endif
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Elimina cualquier referencia posible a paleta en la superficie
// Parametros:
// Devuelve:
// - true: Todo ha ido bien.
// - false: Ha existido algun tipo de problema.
// Notas:
// - Solo valido si la superficie es de mas de 8 Bpp
//////////////////////////////////////////////////////////////////////
bool DXDDSurfaceScreen::UnSetPalette(void)
{
// SOLO si hay superficie creada
DXASSERT(m_pDDSurface != NULL);
// SOLO si la superficie es de mas de 8 Bpp
DXASSERT(GetBpp() > 8);
// Si no tenia asociada paleta, retorna sin mas
if (!m_bPalette) { return true; }
// Procede a asociar la paleta
m_CodeResult = m_pDDSurface->SetPalette(NULL);
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDDError::DXDDErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// Todo correcto
return true;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Comprueba si se esta reproduciendo, o no, el sonido.
// Parametros:
// Devuelve:
// - Si se esta reproduccion devuelve true y false en caso contrario.
// Notas:
//////////////////////////////////////////////////////////////////////
bool DXDSWAVSound::IsPlaying(void)
{
// SOLO si objeto creado
DXASSERT(m_lpDSBuffer);
// Vbles
DWORD dwStatus = 0; // Donde se recogera el status
// Se toma el status y se comprueba
m_lpDSBuffer->GetStatus(&dwStatus);
// Evalua la comprobacion
return (dwStatus & DSBSTATUS_PLAYING) ? true : false;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Asocia una paleta a la superficie, siempre y cuando esta sea de
// 8 Bpp.
// Parametros:
// - poDXPalette: Instancia valida a clase DXDDPalette.
// Devuelve:
// - true: Todo ha ido bien.
// - false: Ha existido algun tipo de problema.
// Notas:
// - Recordar que es imprescindible que que la superficie sea de 8 Bpp.
// - Si se quiere quitar una paleta, basta con llamar a UnSetPalette.
// - Se pueden asociar multiples paletas a una superficie. El efecto
// sera quitar la antigua y poner la nueva. De inmediato, se veran
// los cambios en la informacion grafica de la superficie.
//////////////////////////////////////////////////////////////////////
bool DXDDSurfaceScreen::SetPalette(DXDDPalette* const poDXPalette)
{
// SOLO si hay superficie creada
DXASSERT(m_pDDSurface != NULL);
// SOLO si poDXPalette es una instancia valida
DXASSERT(poDXPalette != NULL);
// SOLO si la superficie es de mas de 8 Bpp
DXASSERT(GetBpp() > 8);
// Procede a asociar la paleta
m_CodeResult = m_pDDSurface->SetPalette(poDXPalette->GetObj());
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDDError::DXDDErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// Actualiza flags
m_bPalette = true;
// Todo correcto
return true;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Asocia una superficie invisible (back) a la superficie primaria
// de tipo complejo creada.
// Parametros:
// - poAttachSurface: Superficie ATTACHED a asociar a la superficie
// primaria compleja.
// Devuelve:
// - true: Todo ha ido bien.
// - false: Han existido problemas.
// Notas:
// - Si ya hay una superficie back asociada, no se tendra de en
// cuenta. Esto es asi, dado que hay operaciones que trabajan
// con varias superficies ATTACH asociadas.
// - Se puede crear manualmente una superficie compleja utilizando
// CreateComplex y despues este metodo.
// - La superficie rebida por parametro pasa a ser del tipo ATTACH y
// sus atributos son adecuadamente cambiados en este metodo.
// - Se puede evitar el uso de CreateComplex y AttachToComplex,
// utilizando la version de CreateComplex que recibe los mismos
// parametros que los dos primeros metodos citados.
//////////////////////////////////////////////////////////////////////
bool DXDDSurfaceScreen::AttachToComplex(DXDDSurfaceBack* const poAttachSurface)
{
// SOLO si hay superficie compleja creada
DXASSERT (NULL != m_pDDSurface);
DXASSERT (DXDDDefs::SURFACETYPE_COMPLEX == m_SurfaceType);
// SOLO si existe puntero a la supercie pasada
DXASSERT(NULL != poAttachSurface);
// SOLO si superficie pasada no esta creada
DXASSERT(DXDDDefs::SURFACETYPE_NOCREATED == poAttachSurface->GetType());
DDSCAPS2 ddscaps; // Descripcion de superficie
// Inicializaciones
memset(&ddscaps, 0, sizeof(ddscaps));
// Establece descripcion
ddscaps.dwCaps = DDSCAPS_BACKBUFFER;
// Asocia superficie pasada a primaria compleja
m_CodeResult = m_pDDSurface->GetAttachedSurface(&ddscaps,
&poAttachSurface->m_pDDSurface);
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDDError::DXDDErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// Actualiza valores de superficie ATTACH pasada y asociada
poAttachSurface->m_dwWidth = m_dwWidth;
poAttachSurface->m_dwHeight = m_dwHeight;
SetPixelFormat();
poAttachSurface->m_SurfaceType = DXDDDefs::SURFACETYPE_ATTACHED;
// Todo correcto
return true;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Crea un nuevo buffer que utiliza los mismos recursos e informacion
// que el recibido como parametro. Este metodo NO aloja en memoria un
// fichero .wav.
// Parametros:
// - poDXSound: Objeto DirectSound.
// - poDSBufferSource: Buffer origen sobre el que realizar la duplicacion.
// Devuelve:
// - true: Si no ha existido ningun problema.
// - false: Si ha ocurrido algun problema en el parametro recibido o
// bien al ir a duplicar.
// Notas:
// - MUY IMPORTANTE: La llamada a este metodo no siempre tendra exito.
// DirectX no dejara crear un buffer duplicado en software si el
// original esta en hardware.
// - Al duplicar un buffer, realmente se crea una referencia a otro
// buffer ya existente pero pudiendo modificar sus atributos y
// pudiendo tocarlo o pararlo libremente. El unico problema
// se derivara al querer cambiar el contenido del buffer. Realizar
// un cambio en el mismo afectara a todos los buffers duplicados
// que apunten a el, incluido el buffer original.
// - En el caso de que ya existiera un buffer secundario, este se
// liberara.
//////////////////////////////////////////////////////////////////////
bool DXDSWAVSound::Create(DXSound* const poDXSound,
DXDSWAVBuffer* const poDSBufferSource)
{
// SOLO si hay existencia de objeto DirectSound
DXASSERT(poDXSound != NULL);
DXASSERT(poDXSound->GetObj() != NULL);
// Si ya existia buffer secundario se libera
if (m_lpDSBuffer) {
Destroy();
}
// Duplica buffer
m_CodeResult = poDXSound->GetObj()->DuplicateSoundBuffer(poDSBufferSource->GetObj(),
&m_lpDSBuffer);
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// Todo correcto
return true;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Devuelve el valor actual del volumen del sonido.
// Parametros:
// - lVolume: Referencia a la vble en donde alojar el volumen.
// Devuelve:
// - plVolume: Valor del volumen.
// - Por funcion:
// - true: Si todo se ha realizado con exito.
// - false: si ha existido algun problema.
// Notas:
// - MUY IMPORTANTE: Para trabajar con este control es necesario
// haber pasado al metodo Create el flag DSBCAPS_CTRLVOLUME.
//////////////////////////////////////////////////////////////////////
bool DXDSWAVSound::GetVolume(LONG& lVolume)
{
// SOLO si hay buffer secundario
DXASSERT(m_lpDSBuffer != NULL);
// Obtiene valor del volumen
m_CodeResult = m_lpDSBuffer->GetVolume(&lVolume);
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// Todo correcto
return true;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Establece el valor para el sonido. Por defecto establece una
// atenuacion a medio camino entre el volumen maximo y el volumen
// minimo.
// Parametros:
// - lVolume: Volumen para el sonido. Cuanto mas proximo a cero
// menor atenuacion y mayor volumen. El valor maximo del sonido
// se encuentra en DSBVOLUME_MAX y el minimo en DSBVOLUME_MIN.
// Devuelve:
// - true: Si la operacion se ha realizado con exito.
// - false: Si ha existido algun problema al modificar el volumen.
// Notas:
// - MUY IMPORTANTE: Para trabajar con este control es necesario
// haber pasado al metodo Create el flag DSBCAPS_CTRLVOLUME.
// - En caso de sobrepasar los maximos y minimos del sonido con
// lVolume se devolvera true y se acotara convenientemente.
//////////////////////////////////////////////////////////////////////
bool DXDSWAVSound::SetVolume(const LONG& lVolume)
{
// SOLO si hay buffer secundario
DXASSERT(m_lpDSBuffer != NULL);
// Establece volumen
m_CodeResult = m_lpDSBuffer->SetVolume(lVolume);
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// Todo correcto
return true;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Obtiene la posicion del puntero de lectura sobre el buffer.
// Parametros:
// - pdwPlayPos: Direccion de la vble en donde almacenar la
// posicion de lectura.
// Devuelve:
// - dwPlayPos: Referencia a la vble donde depositar el valor.
// - Por funcion:
// - true: Si la operacion ha salido con exito.
// - false: Si ha ocurrido algun problema.
// Notas:
//////////////////////////////////////////////////////////////////////
bool DXDSWAVSound::GetPlayPosition(DWORD& dwPlayPos)
{
// SOLO si hay buffer secundario
DXASSERT(m_lpDSBuffer != NULL);
// Obtiene posicion de lectura
m_CodeResult = m_lpDSBuffer->GetCurrentPosition(&dwPlayPos, NULL);
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// Todo correcto
return true;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Comprueba si el objeto esta creado sobre dispositivo hardware
// o software.
// Parametros:
// Devuelve:
// - Si esta en hardware true. Si esta en software false.
// Notas:
//////////////////////////////////////////////////////////////////////
bool DXDSWAVSound::IsInHardware(void)
{
// SOLO si objeto creado
DXASSERT(m_lpDSBuffer);
// Toma la informacion del buffer para saber donde se ha alojado
DSBCAPS dsbcaps;
memset(&dsbcaps, 0, sizeof(DSBCAPS));
dsbcaps.dwSize = sizeof(DSBCAPS);
m_CodeResult = m_lpDSBuffer->GetCaps(&dsbcaps);
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDSError::DXDSErrorToString(m_CodeResult, m_sLastCode);
return false;
}
// Retorna resultado
if (dsbcaps.dwFlags & DSBCAPS_LOCHARDWARE) { return true; }
return false;
}
//////////////////////////////////////////////////////////////////////
// Descripcion:
// - Realiza la operacion de intercambio de paginas en una superficie
// primaria compleja (COMPLEX).
// En caso de que se este trabajando con una superficie PRIMARY
// que posea un backbuffer falso asociado, la operacion consistira
// en copiar el contenido del backbuffer sobre la superficie primaria
// mediante un simple bliteado.
// Parametros:
// - dwFlags: Flag con los que hacer el intercambio de paginas. Por
// defecto es DDFLIP_WAIT. Consultar ayuda de DirectX para mas
// informacion.
// Devuelve:
// - true: Todo ha ido bien.
// - false: Ha existido algun tipo de problema.
// Notas:
// - Es imprescindible que este metodo lo llame la superficie
// primaria (pero siempre y cuando, esta superficie primera tenga
// un BackBuffer asociado, es decir, que sea una sup. compleja).
//////////////////////////////////////////////////////////////////////
bool DXDDSurfaceScreen::Flip(const dword dwFlags)
{
// SOLO si la superficie es COMPLEX
DXASSERT(DXDDDefs::SURFACETYPE_COMPLEX == m_SurfaceType);
// Se realiza el flip
#ifdef _DEBUG
m_CodeResult = m_pDDSurface->Flip(NULL, dwFlags);
if (FAILED(m_CodeResult)) {
// Hay problemas
DXDDError::DXDDErrorToString(m_CodeResult, m_sLastCode);
return false;
}
#else
m_pDDSurface->Flip(NULL, dwFlags);
#endif
//m_pDDSurface->BltFast(0, 0, m_poBackBuffer->GetObj(), NULL, DDBLTFAST_WAIT);
// Todo correcto
return true;
}
BOOL ShiftDate_Month(COleDateTime &refDate, int nMonthCount)
{
SYSTEMTIME sysDate;
if (!GetAsSystemTime(refDate, sysDate))
return FALSE;
int nYearNew = sysDate.wYear + nMonthCount / 12;
int nMonthNew = sysDate.wMonth + nMonthCount % 12;
if (nMonthNew > 12)
{
nMonthNew -= 12 * (nMonthCount / abs(nMonthCount));
nYearNew++;
}
else if (nMonthNew <= 0)
{
nYearNew--;
nMonthNew += 12;
DXASSERT(nMonthNew >= 1 && nMonthNew <= 12);
}
return COleDateTime::valid == refDate.SetDate(nYearNew, nMonthNew, 1);
}