tkwingdi.c

linux系统下的音频通信

/*
 * tkWinGdi.c --
 *
 *	implements checking of gdicalls and optimizing SelectObjects
 *
 * Copyright (c) Brueckner & Jarosch Ing.GmbH,Erfurt,Germany 1997
 * hacked by Leo
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 */
#ifdef WTK
#include <windows.h>
#pragma hdrstop
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>
#include "testwver.h"
#include "panic.h"
#include "ckalloc.h"
#include "dprintf.h"
#include "ckgraph.h"
#else
#include "tkWinInt.h"
#endif

#ifdef CKGRAPH_IMP

#define CKOBJ_UNKNOWN         0
#define CKOBJ_PEN             OBJ_PEN
#define CKOBJ_BRUSH           OBJ_BRUSH
#define CKOBJ_DC              OBJ_DC
#define CKOBJ_METADC          OBJ_METADC
#define CKOBJ_PAL             OBJ_PAL
#define CKOBJ_FONT            OBJ_FONT
#define CKOBJ_BITMAP          OBJ_BITMAP
#define CKOBJ_REGION          OBJ_REGION
#define CKOBJ_METAFILE        OBJ_METAFILE
#define CKOBJ_MEMDC           OBJ_MEMDC
#define CKOBJ_EXTPEN          OBJ_EXTPEN
#define CKOBJ_ENHMETADC       OBJ_ENHMETADC
#define CKOBJ_ENHMETAFILE     OBJ_ENHMETAFILE

#ifndef WTK
static int  Wtk_test_win32s(void){
  return tkpIsWin32s;
}
#endif
/*Stock Objects, must be initialized first!*/
static HPEN     stock_NULL_PEN=NULL;
static HPEN     stock_WHITE_PEN=NULL;
static HPEN     stock_BLACK_PEN=NULL;
static HBRUSH   stock_NULL_BRUSH=NULL;
static HBRUSH   stock_WHITE_BRUSH=NULL;
static HBRUSH   stock_BLACK_BRUSH=NULL;
static HBRUSH   stock_GRAY_BRUSH=NULL;
static HBRUSH   stock_DKGRAY_BRUSH=NULL;
static HBRUSH   stock_LTGRAY_BRUSH=NULL;
static HFONT    stock_SYSTEM_FONT=NULL;
static HFONT    stock_OEM_FIXED_FONT=NULL;
static HFONT    stock_SYSTEM_FIXED_FONT=NULL;
static HFONT    stock_ANSI_VAR_FONT=NULL;
static HFONT    stock_ANSI_FIXED_FONT=NULL;
static HFONT    stock_DEVICE_DEFAULT_FONT=NULL;
static HPALETTE stock_DEFAULT_PALETTE=NULL;

/*should be the first function called in this package*/
void CkGraph_Init(HINSTANCE hInstance){
  stock_NULL_PEN=GetStockObject(NULL_PEN);
  stock_WHITE_PEN=GetStockObject(WHITE_PEN);
  stock_BLACK_PEN=GetStockObject(BLACK_PEN);
  stock_NULL_BRUSH=GetStockObject(NULL_BRUSH);
  stock_WHITE_BRUSH=GetStockObject(WHITE_BRUSH);
  stock_BLACK_BRUSH=GetStockObject(BLACK_BRUSH);
  stock_GRAY_BRUSH=GetStockObject(GRAY_BRUSH);
  stock_DKGRAY_BRUSH=GetStockObject(DKGRAY_BRUSH);
  stock_LTGRAY_BRUSH=GetStockObject(LTGRAY_BRUSH);
  stock_SYSTEM_FONT=GetStockObject(SYSTEM_FONT);
  stock_OEM_FIXED_FONT=GetStockObject(OEM_FIXED_FONT);
  stock_SYSTEM_FIXED_FONT=GetStockObject(SYSTEM_FIXED_FONT);
  stock_ANSI_VAR_FONT=GetStockObject(ANSI_VAR_FONT);
  stock_ANSI_FIXED_FONT=GetStockObject(ANSI_FIXED_FONT);
  stock_DEVICE_DEFAULT_FONT=GetStockObject(DEVICE_DEFAULT_FONT);
  stock_DEFAULT_PALETTE=GetStockObject(DEFAULT_PALETTE);
}
static int is_stockobject(int type,HGDIOBJ hobj){
  switch(type){
    case CKOBJ_PEN:   if(stock_NULL_PEN==hobj)            return 1;
                      if(stock_WHITE_PEN==hobj)           return 1;
                      if(stock_BLACK_PEN==hobj)           return 1;
                      break;
    case CKOBJ_BRUSH: if(stock_NULL_BRUSH==hobj)          return 1;
                      if(stock_WHITE_BRUSH==hobj)         return 1;
                      if(stock_BLACK_BRUSH==hobj)         return 1;
                      if(stock_GRAY_BRUSH==hobj)          return 1;
                      if(stock_DKGRAY_BRUSH==hobj)        return 1;
                      if(stock_LTGRAY_BRUSH==hobj)        return 1;
                      break;
    case CKOBJ_FONT:  if(stock_SYSTEM_FONT==hobj)         return 1;
                      if(stock_OEM_FIXED_FONT==hobj)      return 1;
                      if(stock_SYSTEM_FIXED_FONT==hobj)   return 1;
                      if(stock_ANSI_VAR_FONT==hobj)       return 1;
                      if(stock_ANSI_FIXED_FONT==hobj)     return 1;
                      if(stock_DEVICE_DEFAULT_FONT==hobj) return 1;
                      break;
    case CKOBJ_PAL:   if(stock_DEFAULT_PALETTE==hobj)      return 1;
                      break;
  }
  return 0;
}
static char* obj_type(int type){
  switch (type){
    case CKOBJ_UNKNOWN:     return "UNKNOWN";
    case CKOBJ_PEN:         return "PEN";
    case CKOBJ_BRUSH:       return "BRUSH";
    case CKOBJ_DC:          return "DC";
    case CKOBJ_METADC:      return "METADC";
    case CKOBJ_PAL:         return "PAL";
    case CKOBJ_FONT:        return "FONT";
    case CKOBJ_BITMAP:      return "BITMAP";
    case CKOBJ_REGION:      return "REGION";
    case CKOBJ_METAFILE:    return "METAFILE";
    case CKOBJ_MEMDC:       return "MEMDC";
    case CKOBJ_EXTPEN:      return "EXTPEN";
    case CKOBJ_ENHMETADC:   return "ENHMETADC";
    case CKOBJ_ENHMETAFILE: return "ENHMETAFILE";
  }
  return "UNKNOWN";
}

#ifdef CKGRAPH_DEBUG
int tkWinGdi_verbose=1;
int tkWinGdi_CreatePen;
int tkWinGdi_ExtCreatePen;
int tkWinGdi_CreateSolidBrush;
int tkWinGdi_CreatePatternBrush;
int tkWinGdi_CreateDIBitmap;
int tkWinGdi_CreateCompatibleBitmap;
int tkWinGdi_LoadBitmap;
int tkWinGdi_CreateBitmap;
int tkWinGdi_CreateRectRgn;
int tkWinGdi_CreateFont;
int tkWinGdi_CreateFontIndirect;
int tkWinGdi_CreatePalette;
int tkWinGdi_GetDC;
int tkWinGdi_CreateDC;
int tkWinGdi_ReleaseDC;
int tkWinGdi_CreateCompatibleDC;
int tkWinGdi_DeleteDC;
int tkWinGdi_BeginPaint;
int tkWinGdi_EndPaint;
int tkWinGdi_SelectObject;
int tkWinGdi_SelectBitmap;
int tkWinGdi_SelectPen;
int tkWinGdi_SelectBrush;
int tkWinGdi_SelectPalette;
int tkWinGdi_SelectFont;
int tkWinGdi_DeleteObject;
int tkWinGdi_DeleteBrush;
int tkWinGdi_DeletePen;
int tkWinGdi_DeleteFont;
int tkWinGdi_DeleteBitmap;
int tkWinGdi_DeletePalette;
int tkWinGdi_RealizePalette;
int tkWinGdi_SetROP2;
int tkWinGdi_SetBkMode;
int tkWinGdi_SetBkColor;
int tkWinGdi_SetTextColor;
int tkWinGdi_SelectClipRgn;
int tkWinGdi_OffsetClipRgn;
int tkWinGdi_FillRect;
int tkWinGdi_Polyline;
int tkWinGdi_Polygon;
int tkWinGdi_Arc;
int tkWinGdi_Chord;
int tkWinGdi_Pie;
int tkWinGdi_Rectangle;
int tkWinGdi_TextOut;
int tkWinGdi_ExtTextOut;
int tkWinGdi_SetPolyFillMode;
int tkWinGdi_SetPaletteEntries;
int tkWinGdi_ResizePalette;
int tkWinGdi_BitBlt;

#ifdef CKGRAPH_TRACE
static int dotracing=0;
static int tracefirst=0;
static char tracefile[255];
void  CkGraph_SetTracing(int trace){
  dotracing=trace;
}
int   CkGraph_GetTracing(void){
  return dotracing;
}
char* CkGraph_GetTraceFile(void){
  return tracefile;
}
static void openfirst(void){
  int i;
  tracefirst=1;
  for(i=0;i<100;i++){
     FILE* f;
     sprintf(tracefile,"tgdi%d.log",i);
     if((f=fopen(tracefile,"r"))==NULL){
       break;
     } else {
       fclose(f);
     }
  }
}
void gdiprintf(const char *format, ...) {
  va_list argList;
  FILE* ftrace;
  if(!dotracing)
    return;
  if(!tracefirst){
     openfirst();
  }
  ftrace=fopen(tracefile,"a");
  if(ftrace!=NULL){
    va_start(argList,format);
    (void) vfprintf(ftrace,format,argList);
    va_end(argList);
    fclose(ftrace);
  }
}
#else
static int dummytrace;
void  CkGraph_SetTracing(int trace){
  dummytrace=trace;
}
int   CkGraph_GetTracing(void){
  return 0;
}
char* CkGraph_GetTraceFile(void){
  return "";
}
#endif
#endif
static int convert_gdiobjtype(int wingditype){
  int type;
  switch (wingditype){
    case 0:               type=CKOBJ_UNKNOWN;break;
    case OBJ_BITMAP:      type=CKOBJ_BITMAP;break;
    case OBJ_BRUSH:       type=CKOBJ_BRUSH;break;
    case OBJ_FONT:        type=CKOBJ_FONT;break;
    case OBJ_PAL:         type=CKOBJ_PAL;break;
    case OBJ_PEN:         type=CKOBJ_PEN;break;
    case OBJ_EXTPEN:      type=CKOBJ_EXTPEN;break;
    case OBJ_REGION:      type=CKOBJ_REGION;break;
    case OBJ_DC:          type=CKOBJ_DC;break;
    case OBJ_MEMDC:       type=CKOBJ_MEMDC;break;
    case OBJ_METAFILE:    type=CKOBJ_METAFILE;break;
    case OBJ_METADC:      type=CKOBJ_METADC;break;
    case OBJ_ENHMETAFILE: type=CKOBJ_ENHMETAFILE;break;
    case OBJ_ENHMETADC:   type=CKOBJ_ENHMETADC;break;
    default:              type=CKOBJ_UNKNOWN;break;
  }
  return type;
}
#ifdef WTK
typedef char* ClientData;
#endif

/*
 * define's a linked list of CompatibleDC's , if a DC was added to
 * this list it never dies upon program termination
 *
 */
typedef struct _CompatDC {
  HDC hdc;
#ifdef CKGRAPH_DEBUG
  HBITMAP hbitmap;
#endif
  int used;
  struct _CompatDC* next;
} CompatDC;
/*
 * listhead
 */
static CompatDC* compatDCList=NULL;
static CompatDC* currcompat=NULL;
/*
 * number of DC's in the list
 */
static int xhdcs=0;
/*
 *----------------------------------------------------------------------
 * AddCompatDC --
 *	Adds a CompatibleDC to our list of known CompatibleDC's.
 *----------------------------------------------------------------------
 */
static void AddCompatDC(HDC hdc) {
    CompatDC *hdcElem;

    hdcElem = (CompatDC *) ckalloc(sizeof(CompatDC));
    hdcElem->next = compatDCList;
    hdcElem->hdc = hdc;
#ifdef CKGRAPH_DEBUG
    hdcElem->hbitmap=(HBITMAP)0;
#endif
    hdcElem->used=1;
    currcompat = compatDCList = hdcElem;
    xhdcs++;
}
/*
 *----------------------------------------------------------------------
 * RemoveCompatDC --
 *	Removes a CompatibleDC from our list of known CompatibleDC's
 *----------------------------------------------------------------------
 */
static void RemoveCompatDC(HDC hdc) {
  CompatDC *prev, *curr, *next;
  for (prev = NULL, curr = compatDCList; curr != NULL; prev = curr, curr = next)  {
    next = curr->next;
    if (curr->hdc == hdc) {
      if (prev != NULL) {
        prev->next = curr->next;
      } else {
        compatDCList = curr->next;
      }
      xhdcs--;
      if(xhdcs<0)
        panic("xhdcs<0 in RemoveCompatDC");
      if(currcompat==curr)
        currcompat=NULL;
      ckfree((char *) curr);
      return;
    }
  }
}
#define FINDFREECOMPAT() \
  (currcompat!=NULL &&  currcompat->used==0 ) ? currcompat : \
                                          FindFreeCompatDC()
/*
 *----------------------------------------------------------------------
 * FindFreeCompatDC --
 *	Finds an unused CompatibleDC
 *----------------------------------------------------------------------
 */
static CompatDC* FindFreeCompatDC(void) {
    CompatDC  *curr;
    for (curr = compatDCList; curr != NULL; curr = curr->next) {
      if(curr->used==0)
        return currcompat=curr;
    }
    return 0;
}
#define FINDCOMPAT(_hdc) \
  (currcompat!=NULL && currcompat->hdc==(_hdc) ) ? currcompat : FindCompatDC(_hdc)
/*
 *----------------------------------------------------------------------
 * FindCompatDC --
 *	Searches a given CompatibleDC in the List of CompatibleDC's
 *----------------------------------------------------------------------
 */
static CompatDC* FindCompatDC(HDC hdc) {
  CompatDC *curr;
  for (curr = compatDCList; curr != NULL; curr = curr->next) {
    if (curr->hdc == hdc) {
      return currcompat=curr;
    }
  }
  return NULL;
}
/*
 *----------------------------------------------------------------------
 * CkGraph_GetHashedDC --
 *	searches a free element in the list, if nothing is found, creates
 *      a new CompatibleDC and adds it to the list
 *----------------------------------------------------------------------
 */
static int clearTextColor=0x0;
static int clearBkColor=0xffffff;
static int clearBkMode=OPAQUE;
HDC CkGraph_GetHashedDC(void){
   CompatDC* pe=FINDFREECOMPAT();
   if(!pe){
     static int first=1;
     HDC hdc=CkCreateCompatibleDC(NULL);
     if(!hdc)
       panic("No compatDC in CkGraph_GetHashedDC");
     if(first){
       first=0;
         clearTextColor=GetTextColor(hdc);
         clearBkColor=GetBkColor(hdc);
         clearBkMode=GetBkMode(hdc);
     }
     AddCompatDC( hdc);
     return hdc;
   }
   pe->used=1;
   return pe->hdc;
};
/*
 *----------------------------------------------------------------------
 * CkGraph_ReleaseHashedDC --
 *	releases a list element, the CompatibleDC remains allocated
 *----------------------------------------------------------------------
 */
void CkGraph_ReleaseHashedDC(HDC hdc){
  CompatDC* pe;
  //if(compatDCList==NULL)
  //  return;
  if((pe=FINDCOMPAT(hdc))==NULL){
    panic("Could not find a hdc in CkGraph_ReleaseHashedDC");
  }
  pe->used=0;
}
/*
 *----------------------------------------------------------------------
 * CkGraph_FreeHashedDCs --
 *	frees all allocated DCs during termination of the program
 *----------------------------------------------------------------------
 */
void CkGraph_FreeHashedDCs(void) {
  while(compatDCList!=NULL){
    HDC hdc=compatDCList->hdc;
    RemoveCompatDC(hdc);