xlate.c

这是一个开放源代码的与WINNT/WIN2K/WIN2003兼容的操作系统

   USHORT SourcePalType, HPALETTE PaletteDest, HPALETTE PaletteSource,
   ULONG BackgroundColor)
{
   XLATEOBJ *XlateObj;
   XLATEGDI *XlateGDI;
   PALGDI *SourcePalGDI;

   XlateGDI = EngAllocMem(0, sizeof(XLATEGDI), TAG_XLATEOBJ);
   if (XlateGDI == NULL)
   {
      DPRINT1("Failed to allocate memory for a XLATE structure!\n");
      return NULL;
   }
   XlateObj = GDIToObj(XlateGDI, XLATE);

   SourcePalGDI = PALETTE_LockPalette(PaletteSource);
   /* FIXME - SourcePalGDI can be NULL!!! Handle this case instead of ASSERT! */
   ASSERT(SourcePalGDI);

   if (SourcePalType == 0)
      SourcePalType = SourcePalGDI->Mode;

   XlateObj->iSrcType = SourcePalType;
   XlateObj->iDstType = PAL_INDEXED;

   /* Store handles of palettes in internal Xlate GDI object (or NULLs) */
   XlateGDI->DestPal = PaletteDest;
   XlateGDI->SourcePal = PaletteSource;

   XlateObj->flXlate = XO_TO_MONO;
   XlateObj->cEntries = 1;
   XlateObj->pulXlate = &XlateGDI->BackgroundColor;
   switch (SourcePalType)
   {
      case PAL_INDEXED:
         XlateGDI->BackgroundColor = NtGdiGetNearestPaletteIndex(
            PaletteSource, BackgroundColor);
         break;
      case PAL_BGR:
         XlateGDI->BackgroundColor = BackgroundColor;
         break;
      case PAL_RGB:
         XlateGDI->BackgroundColor =
            ((BackgroundColor & 0xFF) << 16) |
            ((BackgroundColor & 0xFF0000) >> 16) |
            (BackgroundColor & 0xFF00);
         break;
      case PAL_BITFIELDS:
         {
            BitMasksFromPal(SourcePalType, SourcePalGDI, &XlateGDI->RedMask,
               &XlateGDI->BlueMask, &XlateGDI->GreenMask);
            XlateGDI->RedShift = CalculateShift(0xFF) - CalculateShift(XlateGDI->RedMask);
            XlateGDI->GreenShift = CalculateShift(0xFF00) - CalculateShift(XlateGDI->GreenMask);
            XlateGDI->BlueShift = CalculateShift(0xFF0000) - CalculateShift(XlateGDI->BlueMask);
            XlateGDI->BackgroundColor = ShiftAndMask(XlateGDI, BackgroundColor);
         }
         break;
   }

   PALETTE_UnlockPalette(SourcePalGDI);

   return XlateObj;
}

XLATEOBJ* FASTCALL
IntEngCreateSrcMonoXlate(HPALETTE PaletteDest,
                         ULONG ForegroundColor,
                         ULONG BackgroundColor)
{
   XLATEOBJ *XlateObj;
   XLATEGDI *XlateGDI;
   PALGDI *DestPalGDI;

   DestPalGDI = PALETTE_LockPalette(PaletteDest);
   if (DestPalGDI == NULL)
      return NULL;

   XlateGDI = EngAllocMem(0, sizeof(XLATEGDI), TAG_XLATEOBJ);
   if (XlateGDI == NULL)
   {
      PALETTE_UnlockPalette(DestPalGDI);
      DPRINT1("Failed to allocate memory for a XLATE structure!\n");
      return NULL;
   }
   XlateObj = GDIToObj(XlateGDI, XLATE);

   XlateObj->cEntries = 2;
   XlateObj->pulXlate = EngAllocMem(0, sizeof(ULONG) * XlateObj->cEntries, 0);
   if (XlateObj->pulXlate == NULL)
   {
      PALETTE_UnlockPalette(DestPalGDI);
      EngFreeMem(XlateGDI);
      return NULL;
   }

   XlateObj->iSrcType = PAL_INDEXED;
   XlateObj->iDstType = DestPalGDI->Mode;

   /* Store handles of palettes in internal Xlate GDI object (or NULLs) */
   XlateGDI->SourcePal = NULL;
   XlateGDI->DestPal = PaletteDest;

   XlateObj->flXlate = XO_TABLE;

   BitMasksFromPal(DestPalGDI->Mode, DestPalGDI, &XlateGDI->RedMask,
      &XlateGDI->BlueMask, &XlateGDI->GreenMask);

   XlateGDI->RedShift =   CalculateShift(RGB(0xFF, 0x00, 0x00)) - CalculateShift(XlateGDI->RedMask);
   XlateGDI->GreenShift = CalculateShift(RGB(0x00, 0xFF, 0x00)) - CalculateShift(XlateGDI->GreenMask);
   XlateGDI->BlueShift =  CalculateShift(RGB(0x00, 0x00, 0xFF)) - CalculateShift(XlateGDI->BlueMask);

   XlateObj->pulXlate[0] = ShiftAndMask(XlateGDI, BackgroundColor);
   XlateObj->pulXlate[1] = ShiftAndMask(XlateGDI, ForegroundColor);

   if (XlateObj->iDstType == PAL_INDEXED)
   {
      XlateObj->pulXlate[0] =
         ClosestColorMatch(XlateGDI,
                           (LPPALETTEENTRY)&XlateObj->pulXlate[0],
                           DestPalGDI->IndexedColors,
                           DestPalGDI->NumColors);
      XlateObj->pulXlate[1] =
         ClosestColorMatch(XlateGDI,
                           (LPPALETTEENTRY)&XlateObj->pulXlate[1],
                           DestPalGDI->IndexedColors,
                           DestPalGDI->NumColors);
   }

   PALETTE_UnlockPalette(DestPalGDI);

   return XlateObj;
}

HPALETTE FASTCALL
IntEngGetXlatePalette(XLATEOBJ *XlateObj,
                      ULONG Palette)
{
   XLATEGDI *XlateGDI = ObjToGDI(XlateObj, XLATE);
   switch (Palette)
   {
   case XO_DESTPALETTE:
      return XlateGDI->DestPal;
      break;

   case XO_SRCPALETTE:
      return XlateGDI->SourcePal;
      break;
   }
   return 0;
}

/* PUBLIC FUNCTIONS ***********************************************************/

/*
 * @implemented
 */
VOID FASTCALL
EngDeleteXlate(XLATEOBJ *XlateObj)
{
   XLATEGDI *XlateGDI;

   if (XlateObj == NULL)
   {
      DPRINT1("Trying to delete NULL XLATEOBJ\n");
      return;
   }

   XlateGDI = ObjToGDI(XlateObj, XLATE);

   if ((XlateObj->flXlate & XO_TABLE) &&
       XlateObj->pulXlate != NULL)
   {
      EngFreeMem(XlateObj->pulXlate);
   }

   EngFreeMem(XlateGDI);
}

/*
 * @implemented
 */
PULONG STDCALL
XLATEOBJ_piVector(XLATEOBJ *XlateObj)
{
   if (XlateObj->iSrcType == PAL_INDEXED)
   {
      return XlateObj->pulXlate;
   }

   return NULL;
}

/*
 * @implemented
 */
ULONG STDCALL
XLATEOBJ_iXlate(XLATEOBJ *XlateObj, ULONG Color)
{
   XLATEGDI *XlateGDI;
   PALGDI *PalGDI;
   ULONG Closest;

   /* Return the original color if there's no color translation object. */
   if (!XlateObj)
      return Color;

   if (XlateObj->flXlate & XO_TRIVIAL)
      return Color;
    
   if (XlateObj->flXlate & XO_TABLE)
   {
      if (Color >= XlateObj->cEntries)
          Color %= XlateObj->cEntries;

      return XlateObj->pulXlate[Color];
   }


   if (XlateObj->flXlate & XO_TO_MONO)
      return Color == XlateObj->pulXlate[0];

   XlateGDI = ObjToGDI(XlateObj, XLATE);

   if (XlateGDI->UseShiftAndMask)
      return ShiftAndMask(XlateGDI, Color);

   if (XlateObj->iSrcType == PAL_RGB || XlateObj->iSrcType == PAL_BGR ||
       XlateObj->iSrcType == PAL_BITFIELDS)
   {
      /* FIXME: should we cache colors used often? */
      /* FIXME: won't work if destination isn't indexed */

      /* Convert the source color to the palette RGB format. */
      Color = ShiftAndMask(XlateGDI, Color);

      /* Extract the destination palette. */
      PalGDI = PALETTE_LockPalette(XlateGDI->DestPal);
      if(PalGDI != NULL)
      {
         /* Return closest match for the given color. */
         Closest = ClosestColorMatch(XlateGDI, (LPPALETTEENTRY)&Color, PalGDI->IndexedColors, PalGDI->NumColors);
         PALETTE_UnlockPalette(PalGDI);
         return Closest;
      }
   }

   return 0;
}

/*
 * @implemented
 */
ULONG STDCALL
XLATEOBJ_cGetPalette(XLATEOBJ *XlateObj, ULONG PalOutType, ULONG cPal,
   ULONG *OutPal)
{
   HPALETTE hPalette;
   XLATEGDI *XlateGDI;
   PALGDI *PalGDI;
   ULONG *InPal;

   XlateGDI = ObjToGDI(XlateObj, XLATE);
   if (PalOutType == XO_SRCPALETTE)
      hPalette = XlateGDI->SourcePal;
   else if (PalOutType == XO_DESTPALETTE)
      hPalette = XlateGDI->DestPal;
   else
   {
      UNIMPLEMENTED;
      return 0;
    }

   PalGDI = PALETTE_LockPalette(hPalette);
   if(PalGDI != NULL)
   {
     /* copy the indexed colors into the buffer */

     for(InPal = (ULONG*)PalGDI->IndexedColors;
         cPal > 0;
         cPal--, InPal++, OutPal++)
     {
       *OutPal = *InPal;
     }

     PALETTE_UnlockPalette(PalGDI);

     return cPal;
   }

   return 0;
}

/* EOF */