prj/tech/libsrc/dispdev/wdisp.h

   1 ///////////////////////////////////////////////////////////////////////////////
   2 // $Source: x:/prj/tech/libsrc/dispdev/RCS/wdisp.h $
   3 // $Author: KEVIN $
   4 // $Date: 1998/01/12 15:44:26 $
   5 // $Revision: 1.28 $
   6 //
   7
   8 #ifndef __WDISP_H
   9 #define __WDISP_H
  10
  11 #include <dispbase.h>
  12 #include <wdispapi.h>
  13
  14 #include <thrdtool.h>
  15 #include <relocptr.h>
  16
  17 ///////////////////////////////////////////////////////////////////////////////
  18
  19 F_DECLARE_INTERFACE(IWinApp);
  20
  21 class cWinDisplayProvider;
  22 class cWinDisplayModeOperations;
  23
  24 ///////////////////////////////////////////////////////////////////////////////
  25 //
  26 // STRUCT: sGdiBitmapInfo
  27 //
  28 // Initializes and stores information required to create a GDI bitmap
  29 //
  30
  31 struct sGdiBitmapInfo : public BITMAPINFO
  32 {
  33     sGdiBitmapInfo(int width, int height, int significantDepth);
  34     RGBQUAD bmiColors2[255];
  35 };
  36
  37 // Typedef Task Switch callback function
  38
  39 ///////////////////////////////////////////////////////////////////////////////
  40 //
  41 // CLASS: cWinDisplayDevice
  42 //
  43 // Implements IDisplayDevice.  Acts primarily as an adaptor for instances
  44 // of cWinDisplayProvider and cWinDisplayModeOperations
  45 //
  46
  47 class cWinDisplayDevice : public cDisplayDevice
  48 {
  49 public:
  50     cWinDisplayDevice(IUnknown * pOuterUnknown, eDisplayDeviceKind kind, int flags);
  51     virtual ~cWinDisplayDevice();
  52
  53     ///////////////////////////////////
  54     //
  55     // Query functions for client Providers and Operations
  56     //
  57
  58     //
  59     // Query if the device has been opened
  60     //
  61     BOOL IsOpen() const;
  62
  63     //
  64     // Query if the device is useful (i.e., is in some mode, any mode)
  65     //
  66     BOOL IsModeSet() const;
  67
  68     //
  69     // Query the lock count
  70     //
  71     int GetLockCount() const;
  72
  73     //
  74     // Query kind
  75     //
  76     STDMETHOD_(eDisplayDeviceKind, GetKind)();
  77
  78     //
  79     // Query the creation flags
  80     //
  81     int GetCreateFlags() const;
  82
  83     //
  84     // Temporarily break any lock on surfaces, returning lock count
  85     //
  86     STDMETHOD_(int, BreakLock)();
  87
  88     //
  89     // Restore broken lock
  90     //
  91     STDMETHOD_(void, RestoreLock)(int iLockCount);
  92
  93     //
  94     // Try to gain exclusive use of display object, without locking video memory.
  95     //
  96     STDMETHOD_(BOOL, IsLocked)();
  97
  98     //
  99     // Threading hooks
 100     //
 101     void WaitForMutex();
 102     void ReleaseMutex();
 103     int  BreakMutex();
 104     void RestoreMutex(int);
 105
 106     //
 107     // Get the properties of the current mode
 108     //
 109     const sGrModeInfo & GetCurrentModeInfo() const;
 110
 111     //
 112     // Palette tools
 113     //
 114     struct sPalette256 : public LOGPALETTE
 115     {
 116         sPalette256()
 117         {
 118             palVersion = 0x300;
 119             palNumEntries = 256;
 120         }
 121         PALETTEENTRY AddEntries[255];
 122     };
 123
 124     LOGPALETTE &   GetLogPalette();
 125     PALETTEENTRY * GetPaletteEntries();
 126
 127     // Set kind (must be outside Open/Close pair)
 128     STDMETHOD_(void, SetKind)(eDisplayDeviceKind, int flags);
 129
 130     // Get information about the device
 131     STDMETHOD_(void, GetInfo)(sGrDeviceInfo *, sGrModeInfo *);
 132
 133     // Open/Close the device
 134     STDMETHOD (Open)(sGrModeCap *, int fFlags);
 135     STDMETHOD (Close)();
 136
 137     // Set/get the mode
 138     STDMETHOD (SetMode)(eGrDispMode, int fFlags);
 139     STDMETHOD_(eGrDispMode, GetMode)(sGrModeInfoEx * pOptionalModeInfo);
 140
 141     // Return TRUE of retrace is in progress
 142     STDMETHOD_(BOOL, StatHTrace)();
 143     STDMETHOD_(BOOL, StatVTrace)();
 144
 145     // Set/Get the palette (if 8-bit palletized)
 146     STDMETHOD_(BOOL, SetPalette)(unsigned uStart, unsigned n, const unsigned char * pRGBs);
 147     STDMETHOD_(BOOL, GetPalette)(unsigned uStart, unsigned n, unsigned char * pRGBs);
 148
 149     // Flip the visible surface. No-op if no back buffer.
 150     STDMETHOD (PageFlip)();
 151
 152     // Try to lock video memory.  Locked pointers will be placed in
 153     // structure provided in SetMode(). Returns lock count.
 154     STDMETHOD_(int, Lock)();
 155
 156     // Release a lock on memory
 157     STDMETHOD_(int, Unlock)();
 158
 159     // Verify display reflects what is expected.
 160     STDMETHOD_(void, Flush)();
 161
 162     // Flush a specific region
 163     STDMETHOD_(void, FlushRect)(int x0, int y0, int x1, int y1);
 164
 165     // Add/Remove a pointer to the monitor set.
 166     STDMETHOD_(BOOL, SetMonitor)(tGrDispBits **, eDisplayDeviceMonitorFlag);
 167
 168     // Create a device based bitmap
 169     STDMETHOD (CreateBitmap)(sGrDevBitmapDesc *, int flags, IDeviceBitmap **);
 170
 171     // Locate an IDeviceBitmap for the given sGrBitmap, if any exists
 172     STDMETHOD (FindBitmap)(const sGrBitmap *, IDeviceBitmap **);
 173
 174     //
 175     STDMETHOD (GetRenderTargets)(sGrRenderTargets *);
 176
 177     // Set kind (must be outside Open/Close pair)
 178     STDMETHOD_(void, SetKind2)(eDisplayDeviceKind, int flags, GUID *pDDrawGuid);
 179
 180     // Query kind, flags, and ddraw guid
 181     STDMETHOD_(void, GetKind2)(eDisplayDeviceKind *, int *, GUID **);
 182
 183     // Create a GDI bitmap
 184     HBITMAP CreateGDIBitmap(sGdiBitmapInfo * pBitmapInfo);
 185
 186 private:
 187
 188     ///////////////////////////////////
 189
 190     // Fixes-up monitored pointers
 191     void Sync2DPointers();
 192     void InvalidateBasePointers();
 193
 194     // Manipulation of m_LogicalPalette
 195     static void SetStoredPaletteEntries(unsigned uStart, unsigned n, const unsigned char * pRGBs, int paletteFlags);
 196     static void GetStoredPaletteEntries(unsigned uStart, unsigned n, unsigned char * pRGBs);
 197
 198     ///////////////////////////////////
 199
 200     void DoCursorBltFromGDIScreen(sGrBitmap *, int x, int y);
 201     void DoCursorBltToGDIScreen(sGrBitmap *, int x, int y);
 202
 203     ///////////////////////////////////
 204     //
 205     // Enums and constants
 206     //
 207
 208     enum
 209     {
 210         kTotallyBogusBase = 0xffeeffee,
 211         kPrimaryBogusBase = 0xfefefefe,
 212         kSecondaryBogusBase  = 0xfdfdfdfd
 213     };
 214
 215     enum eWinDispFlags
 216     {
 217                                                  // Start higher than base flags!
 218         kStrictMonitors = 0x10,
 219         kSettingMode    = 0x20                   // because setting the mode often
 220                                                  // requires breaking the display
 221                                                  // device mutex, an additional
 222                                                  // bit ensures the message thread
 223                                                  // doesn't do anything bad
 224     };
 225
 226     ///////////////////////////////////
 227     //
 228     // CLASS: cIWinDisplayDeviceProxy
 229     //
 230     // Simply passes requests to outer object
 231     //
 232
 233     class cIWinDisplayDeviceProxy : public IWinDisplayDevice
 234     {
 235     public:
 236         cIWinDisplayDeviceProxy(cWinDisplayDevice * pOuter, IUnknown * pOuterUnknown)
 237           : m_pOuter(pOuter), m_pTaskSwitchCallback(NULL)
 238         {
 239             INIT_DELEGATION(pOuterUnknown);
 240         }
 241
 242     private:
 243         DECLARE_DELEGATION();
 244
 245         STDMETHOD_(BOOL, ProcessMessage)(UINT msg, WPARAM wParam, LPARAM lParam, long * pRetVal);
 246         STDMETHOD_(void, GetWidthHeight)(unsigned * pWidth, unsigned * pHeight);
 247         STDMETHOD_(void, OnTaskSwitch)  (BOOL);
 248         STDMETHOD_(BOOL, GetDirectDraw) (IDirectDraw **);
 249         STDMETHOD_(void, WaitForMutex)();
 250         STDMETHOD_(void, ReleaseMutex)();
 251         STDMETHOD_(void, CursorBltFromGDIScreen)(sGrBitmap *, int x, int y);
 252         STDMETHOD_(void, CursorBltToGDIScreen)(sGrBitmap *, int x, int y);
 253         STDMETHOD_(BOOL, GetBitmapSurface)(sGrBitmap *, IDirectDrawSurface **);
 254         STDMETHOD_(void, AddTaskSwitchCallback)(WinDispDevCallbackFunc *callback);
 255         STDMETHOD_(void, RemoveTaskSwitchCallback)(int id);
 256
 257         cWinDisplayDevice * m_pOuter;
 258         WinDispDevCallbackFunc *m_pTaskSwitchCallback;
 259     };
 260
 261     friend class cIWinDisplayDeviceProxy;
 262
 263     ///////////////////////////////////
 264     //
 265     // Instance Data
 266     //
 267
 268 public:
 269     GUID *                      m_pDDrawGuid;
 270
 271 private:
 272     int                         m_iLock;
 273     cWinDisplayModeOperations * m_pDisplayModeOperations;
 274
 275     ///////////////////////////////////
 276
 277     sGrModeCap *                m_pModeInfo;
 278     eGrDispMode                 m_CurrentDispMode;
 279
 280     ///////////////////////////////////
 281
 282     eDisplayDeviceKind          m_DisplayDeviceKind;
 283     int                         m_fOptions;
 284     cWinDisplayProvider *       m_pDisplayProvider;
 285     cIWinDisplayDeviceProxy     m_IWinDisplayDeviceProxy;
 286
 287     ///////////////////////////////////
 288
 289     cThreadLock                 m_Mutex;
 290     int                         m_MutexCount;
 291
 292     ///////////////////////////////////
 293
 294     cRelocationSet<tGrDispBits> m_PrimarySurfaceRelocationSet;
 295     cRelocationSet<tGrDispBits> m_SecondarySurfaceRelocationSet;
 296
 297     ///////////////////////////////////
 298
 299     struct sCursorScratch
 300     {
 301         sCursorScratch()
 302         {
 303             hBitmap = NULL;
 304             memset(&bitmap, 0, sizeof(BITMAP));
 305         }
 306
 307         ~sCursorScratch()
 308         {
 309             if (hBitmap)
 310                 DeleteObject(hBitmap);
 311         }
 312
 313         HBITMAP hBitmap;
 314         BITMAP  bitmap;
 315     };
 316
 317     sCursorScratch              m_CursorScratch;
 318
 319     ///////////////////////////////////
 320     //
 321     // Static data
 322     //
 323
 324     static sPalette256          gm_LogicalPalette;
 325
 326 };
 327
 328 ///////////////////////////////////////////////////////////////////////////////
 329 //
 330 // Utility classes for display device mutex
 331 //
 332
 333 class cAutoDisplayMutex
 334 {
 335 public:
 336     cAutoDisplayMutex(cWinDisplayDevice * pWinDisplayDevice)
 337     {
 338         m_pWinDisplayDevice = pWinDisplayDevice;
 339         m_pWinDisplayDevice->WaitForMutex();
 340     }
 341
 342     ~cAutoDisplayMutex()
 343     {
 344         m_pWinDisplayDevice->ReleaseMutex();
 345     }
 346
 347 private:
 348     cWinDisplayDevice * m_pWinDisplayDevice;
 349 };
 350
 351
 352 //
 353 // Yield the display. Sorry, only 1 per scope
 354 //
 355 #define YieldDisplay(pDisplayDevice) \
 356     int _YieldDisplay_iPreviousLock       = pDisplayDevice->BreakLock(); \
 357     int _YieldDisplay_iPreviousMutexLevel = pDisplayDevice->BreakMutex()
 358
 359 #define RegainDisplay(pDisplayDevice) \
 360     m_pDisplayDevice->RestoreMutex(_YieldDisplay_iPreviousMutexLevel);\
 361     m_pDisplayDevice->RestoreLock(_YieldDisplay_iPreviousLock)
 362
 363
 364 ///////////////////////////////////////////////////////////////////////////////
 365 //
 366 // Inline members of cWinDisplayDevice
 367 //
 368
 369 inline BOOL cWinDisplayDevice::IsOpen() const
 370 {
 371     return !!m_pModeInfo;
 372 }
 373
 374 ///////////////////////////////////////
 375
 376 inline BOOL cWinDisplayDevice::IsModeSet() const
 377 {
 378     return (m_pDisplayModeOperations && !(m_flags & kSettingMode));
 379 }
 380
 381 ///////////////////////////////////////
 382
 383 inline int cWinDisplayDevice::GetLockCount() const
 384 {
 385     return m_iLock;
 386 }
 387
 388 ///////////////////////////////////////
 389
 390 inline int cWinDisplayDevice::GetCreateFlags() const
 391 {
 392     return m_fOptions;
 393 }
 394
 395 ///////////////////////////////////////
 396
 397 inline void cWinDisplayDevice::WaitForMutex()
 398 {
 399     m_Mutex.Lock();
 400     m_MutexCount++;
 401 }
 402
 403 ///////////////////////////////////////
 404
 405 inline void cWinDisplayDevice::ReleaseMutex()
 406 {
 407     m_MutexCount--;
 408     m_Mutex.Unlock();
 409 }
 410
 411 ///////////////////////////////////////
 412
 413 inline int cWinDisplayDevice::BreakMutex()
 414 {
 415     m_Mutex.Lock();
 416     const int retVal = m_MutexCount;
 417     while (m_MutexCount)
 418     {
 419         m_Mutex.Unlock();
 420         m_MutexCount--;
 421     }
 422     m_Mutex.Unlock();
 423     return retVal;
 424 }
 425
 426 ///////////////////////////////////////
 427
 428 inline void cWinDisplayDevice::RestoreMutex(int iMutexCount)
 429 {
 430     m_Mutex.Lock();
 431     m_MutexCount += iMutexCount;
 432     while (iMutexCount)
 433     {
 434         m_Mutex.Lock();
 435         iMutexCount--;
 436     }
 437     m_Mutex.Unlock();
 438 }
 439
 440 ///////////////////////////////////////
 441
 442 inline const sGrModeInfo & cWinDisplayDevice::GetCurrentModeInfo() const
 443 {
 444     return EnumModeToModeInfo(m_CurrentDispMode);
 445 }
 446
 447 ///////////////////////////////////////
 448
 449 inline LOGPALETTE & cWinDisplayDevice::GetLogPalette()
 450 {
 451     return gm_LogicalPalette;
 452 }
 453
 454 ///////////////////////////////////////
 455
 456 inline PALETTEENTRY * cWinDisplayDevice::GetPaletteEntries()
 457 {
 458     return gm_LogicalPalette.palPalEntry;
 459 }
 460
 461 ///////////////////////////////////////
 462
 463 inline HBITMAP cWinDisplayDevice::CreateGDIBitmap(sGdiBitmapInfo * pBitmapInfo)
 464 {
 465     HBITMAP hBitmap;
 466     UINT fUsage = (pBitmapInfo->bmiHeader.biCompression == BI_RGB) ? DIB_RGB_COLORS : 0;
 467     void * pDummy;                      // @Note (toml 04-12-96): In winG, the bits argument could be NULL. We have to get it here, even though we retreive it again with the GetObject() below. This section should be cleaned-up
 468
 469     HDC hdcScreen = GetDC(NULL);
 470     hBitmap = CreateDIBSection(hdcScreen, pBitmapInfo, fUsage, &pDummy, NULL, 0);
 471     ReleaseDC(NULL, hdcScreen);
 472     return hBitmap;
 473 }
 474
 475 ///////////////////////////////////////////////////////////////////////////////
 476
 477 #endif /* !__WDISP_H */