util.c

epson公司的一个关于s1d13706的低层驱动程序

      case SURFACE_MAIN_WIN0:
         seGetMainWinResolution(&x, &y);
         printf("MAIN WINDOW (surface 0): %d * %d * %d Bpp\n", x, y, bpp);
         break;

      case SURFACE_MAIN_AND_SUB_WIN0:
      case SURFACE_MAIN_WIN0_SUB_WIN1:
         seGetMainWinResolution(&x, &y);
         printf("MAIN WINDOW (surface 0): %d * %d * %d Bpp\n", x, y, bpp);
         
         seGetSubWinResolution(&x, &y);
         printf("SUB-WINDOW  (surface ");

         if (surface == SURFACE_MAIN_WIN0_SUB_WIN1)
            printf("1");
         else
            printf("0");

         printf("): %d * %d * %d Bpp\n", x, y, bpp);
         break;
      }
}

/*-------------------------------------------------------------------------*/

void DisplaySurfaceHelp(void)
{
   printf("\n"
          "   ds=   |  Surface 0       Surface 1\n"
          "--------------------------------------\n"
          "    0    | MAIN WINDOW         ---\n"
          "    1    | MAIN&SUB-WINDOW     ---\n"
          "    2    | MAIN WINDOW      SUB-WINDOW\n");
}

/*-------------------------------------------------------------------------*/

void ShowActiveDisplaySurface(void)
{
   int tmp;

   /*
   ** "Display Surface: 0=MAIN WINDOW, 1=SUB-WINDOW"
   */
   printf("Display Surface: 0=");

   tmp = 0;

   if (SurfaceDisplayMode[0] & MAIN_WIN)
      {
      printf("MAIN WINDOW");
      ++tmp;
      }

   if (SurfaceDisplayMode[0] & SUB_WIN)
      {
      if (tmp > 0)
         printf(" & ");

      printf("SUB-WINDOW");
      ++tmp;
      }

   if (tmp == 0)
      printf("NONE");

   printf(", 1=");

   tmp = 0;

   if (SurfaceDisplayMode[1] & MAIN_WIN)
      {
      printf("MAIN WINDOW");
      ++tmp;
      }

   if (SurfaceDisplayMode[1] & SUB_WIN)
      {
      if (tmp > 0)
         printf(" & ");

      printf("SUB-WINDOW");
      ++tmp;
      }

   if (tmp == 0)
      printf("NONE");

   printf("\n");
}

/*-----------------------------------------------------------------------*/
// returns surface display mode

int GetSurfaceDisplayMode(int surface)
{
   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         return 0;
         break;

      case SURFACE_MAIN_WIN0:
         if (surface == 0)
            return MAIN_WIN;
         break;

      case SURFACE_MAIN_WIN0_SUB_WIN1:
         if (surface == 0)
            return MAIN_WIN;
         else if (surface == 1)
            return SUB_WIN;
         break;

      case SURFACE_MAIN_AND_SUB_WIN0:
         if (surface == 0)
            return (MAIN_WIN | SUB_WIN);
         break;
      }

   return 0;
}

/*-----------------------------------------------------------------------*/
// returns surface combination

int CalcDisplaySurfaceCombination(void)
{
   if ((SurfaceDisplayMode[0] & MAIN_WIN) && (SurfaceDisplayMode[1] & SUB_WIN))
      return SURFACE_MAIN_WIN0_SUB_WIN1;
   else if ((SurfaceDisplayMode[0] & MAIN_WIN) && (SurfaceDisplayMode[0] & SUB_WIN))
      return SURFACE_MAIN_AND_SUB_WIN0;
   else
      return SURFACE_MAIN_WIN0;
}

/*-----------------------------------------------------------------------*/
// returns -1 if no active surface
// otherwise returns number of active surface

int GetActiveSurfaceNumber(void)
{
   int CurrentDisplayMode;

   CurrentDisplayMode = seGetSurfaceDisplayMode();

   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         return -1;

      case SURFACE_MAIN_WIN0:
         if (CurrentDisplayMode & MAIN_WIN)
            return 0;
         break;

      case SURFACE_MAIN_WIN0_SUB_WIN1:
         if (CurrentDisplayMode & MAIN_WIN)
            return 0;
         else if (CurrentDisplayMode & SUB_WIN)
            return 1;
         break;

      case SURFACE_MAIN_AND_SUB_WIN0:
         if (CurrentDisplayMode & (MAIN_WIN | SUB_WIN))
            return 0;
         break;
      }

   return -1;
}

/*-----------------------------------------------------------------------*/
// returns surface number given the desired display mode

int GetSurfaceNumber(unsigned DisplayMode)
{
   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         break;

      case SURFACE_MAIN_WIN0:
         if (DisplayMode & MAIN_WIN)
            return 0;
         break;

      case SURFACE_MAIN_WIN0_SUB_WIN1:
         if (DisplayMode & MAIN_WIN)
            return 0;
         else if (DisplayMode & SUB_WIN)
            return 1;
         break;

      case SURFACE_MAIN_AND_SUB_WIN0:
         if (DisplayMode & (MAIN_WIN | SUB_WIN))
            return 0;
         break;
      }

   return -1;
}

/*-----------------------------------------------------------------------*/

void SetActiveSurfaceNumber(int surface)
{
   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         break;

      case SURFACE_MAIN_WIN0:
         if (surface == 0)
            seSetMainWinAsActiveSurface();
         break;

      case SURFACE_MAIN_WIN0_SUB_WIN1:
         if (surface == 0)
            seSetMainWinAsActiveSurface();
         else if (surface == 1)
            seSetSubWinAsActiveSurface();
         break;

      case SURFACE_MAIN_AND_SUB_WIN0:
         if (surface == 0)
            seSetMainWinAsActiveSurface();
         break;
      }
}

/*-----------------------------------------------------------------------*/

int VirtInit(int surface, DWORD width, DWORD height)
{
   switch (CalcDisplaySurfaceCombination())
      {
      case SURFACE_NONE:
         break;

      case SURFACE_MAIN_WIN0:
         if (surface == 0)
            return seMainWinVirtInit(width, height);
         break;

      case SURFACE_MAIN_WIN0_SUB_WIN1:
         if (surface == 0)
            return seMainWinVirtInit(width, height);
         else if (surface == 1)
            return seSubWinVirtInit(width, height);
         break;

      case SURFACE_MAIN_AND_SUB_WIN0:
         if ((surface == 0) || (surface == 1))
            return seMainAndSubWinVirtInit(width, height);
         break;
      }

   return ERR_FAILED;
}

/*-----------------------------------------------------------------------*/

void DisplaySwivelViewMode(void)
   {
   printf("SwivelView Mode: ");

   switch (LcdOrientation)
      {
      case LANDSCAPE:
      default:
         printf("LANDSCAPE");
         break;

      case ROTATE90:
         printf("SWIVELVIEW 90 DEGREES");
         break;

      case ROTATE180:
         printf("SWIVELVIEW 180 DEGREES");
         break;

      case ROTATE270:
         printf("SWIVELVIEW 270 DEGREES");
         break;
      }

   printf("\n");
   }

/*-------------------------------------------------------------------------*/

void ExitBadConfiguration(void)
{
   printf("\nERROR: Program not configured for LCD.");
   printf("\n       Run 13706CFG and configure for LCD.\n");

   exit(1);
}

/*-------------------------------------------------------------------------*/

void DisplayErrorNotEnoughMemory(unsigned BitsPerPixel)
{
   unsigned count = 0;
   unsigned DisplayMode = 0;
   char szErr[50];
   DisplayMode = GetSurfaceDisplayMode(GetActiveSurfaceNumber());
   szErr[0] = 0;
   count = 0;

   if (DisplayMode & MAIN_WIN)
      {
      strcat(szErr, "MAIN WINDOW");
      ++count;
      }

   if (DisplayMode & SUB_WIN)
      {
      if (count > 0)
         strcat(szErr, " & ");

      strcat(szErr, "SUB-WINDOW");
      ++count;
      }

   if (count == 0)
      strcpy(szErr, "NONE");

   printf(szModeFailed, szErr, BitsPerPixel);
}

/*-------------------------------------------------------------------------*/
// returns 0 if OK
// otherwise returns error value to be returned by main()

int HandleSelectedSurface(void)
   {
   int i;
   unsigned bpp;
   
   bpp = seGetBitsPerPixel();

   seWriteRegDword(REG_MAIN_WIN_DISP_START_ADDR0, 0);
   seWriteRegDword(REG_SUB_WIN_DISP_START_ADDR0, 0);

   SurfaceDisplayMode[0] = 0;
   SurfaceDisplayMode[1] = 0;

   if (!(HalInfo.dwFlags & fVALID_LCD))
      ExitBadConfiguration();

   seMainWinDisplayEnable(TRUE);
   seSubWinDisplayEnable(FALSE);

   seMainWinDisplayBlank(FALSE);

   NumberOfSurfaces = 1;
   SurfaceDisplayMode[0] = MAIN_WIN;

   printf("\n");


   for (i = 0; i < MAX_DISP_SURFACE; ++i)
      {
      if (SurfaceDisplayMode[i] == 0)
         SurfaceDisplayMode[i] = GetSurfaceDisplayMode(i);
      }

   ShowActiveDisplaySurface();
   DisplaySwivelViewMode();

   return 0;
   }

/*-------------------------------------------------------------------------*/