guiproperties.c

这个是boot gui的程序

/*
 *  Start of Zoran Standard Header
 *  Copyright (c) 2005 Zoran Corporation
 *  
 *  
 *  All rights reserved.  Proprietary and confidential.
 *  
 *  DESCRIPTION for guiproperties.c
 *      GUI properties interface
 *  
 *  NEW HISTORY COMMENT (description must be followed by a blank line)
 *  <Enter change description here>

 *  ===== HISTORY of changes in //depot/imgeng/sw/se_gw/gui/guiproperties.c
 *  
 *  13/Dec/05 #7  dstrauss  Brightness should be 0 - 6, displayed 
 *                          as -100% thru +100%
 *  13/Dec/05 #6  dstrauss  Added GPID_PHOTOSIZE
 *  12/Dec/05 #5  dstrauss  Fixed bug in displaying negative values for Cyan,
 *                          Magenta, and Yellow levels.
 *  12/Dec/05 #4  dstrauss  GPMIncrementDisplayValue and 
 *                          GPMDecrementDisplayValue now handle out-of-bounds 
 *                          values and value wrapping.
 *   7/Dec/05 #3  dstrauss  Added papersize and mode properties.  Added defines
 *                          to describe non-numeric property values.  Added
 *                          GPMGetSavedValue().
 *   7/Dec/05 #2  dstrauss  Added code for so properties can have a "display"
 *                          and a "saved" value.  Added code to increment and
 *                          decrement display values, and to moved values from
 *                          display to saved and vice-versa.
 *   6/Dec/05 #1  dstrauss  Created.
 *  
 *
 *  End of Zoran Standard Header
 */
#include "standard.h"
#include "propman.h"

#include "guiproperties.h"

#define PROPVALUE_ERROR   -99999 /* property value error code */

/* Structure to hold a property value.  Values are assumed to be
 * (signed) integers; translation to actual enumerations or
 * strings is done in the handler routine(s).
 * 
 */
typedef struct _s_PropValue {
  guiPID id;
  int displayvalue;
  int savedvalue;
} PropValue;

/* Array containing values of properties.
 * Display values are copied to saved values after
 * a "set" or a cursor up/down operation.
 */
static PropValue propValues[] = {
  { GPID_COPIES, 1, 1 },        /* 1 - 99 */
  { GPID_SCALE, 100, 100 },     /* 25% to 400% */
  { GPID_BRIGHTNESS, 3, 3 },    /* 0 - 6, displayed as -100% through +100% */
  { GPID_CONTRAST, 0, 0 },      /* -100% to +100% */
  { GPID_PAPERSIZE, GPID_PAPERSIZE_LETTER, GPID_PAPERSIZE_LETTER },
  { GPID_PAPERTYPE, GPID_PAPERTYPE_PLAIN, GPID_PAPERTYPE_PLAIN },
  { GPID_QUALITY, GPID_QUALITY_NORMAL, GPID_QUALITY_NORMAL },
  { GPID_CYAN, 0, 0 },          /* -100% to +100% */
  { GPID_MAGENTA, 0, 0 },       /* -100% to +100% */
  { GPID_YELLOW, 0, 0 },        /* -100% to +100% */
  { GPID_SEGMENTATION, GPID_SEGMENTATION_OFF, GPID_SEGMENTATION_OFF },
  { GPID_POSTERMODE, GPID_POSTERMODE_OFF, GPID_POSTERMODE_OFF },
  { GPID_NUP, GPID_NUP_1UP, GPID_NUP_1UP },
  { GPID_MODE, GPID_MODE_PHOTO, GPID_MODE_PHOTO },
  { GPID_PHOTOSIZE, PhotoSize_PHZ4x6, PhotoSize_PHZ4x6 }
};

/* number of items in the list */
#define NUMPROPS (sizeof(propValues)/sizeof(propValues[0]))

static int getDisplayValue(guiPID property)
{
  int index;

  for (index = 0; index < NUMPROPS; index++) {
    if (propValues[index].id == property) {
      return (propValues[index].displayvalue);
    }
  }
  ASSERT(0);
  return (PROPVALUE_ERROR);
}

static int getSavedValue(guiPID property)
{
  int index;

  for (index = 0; index < NUMPROPS; index++) {
    if (propValues[index].id == property) {
      return (propValues[index].savedvalue);
    }
  }
  ASSERT(0);
  return (PROPVALUE_ERROR);
}

static void setDisplayValue(guiPID property, int newvalue)
{
  int index;

  for (index = 0; index < NUMPROPS; index++) {
    if (propValues[index].id == property) {
      propValues[index].displayvalue = newvalue;
    }
  }
}

static void setSavedValue(guiPID property, int newvalue)
{
  int index;

  for (index = 0; index < NUMPROPS; index++) {
    if (propValues[index].id == property) {
      propValues[index].savedvalue = newvalue;
    }
  }
}


/* check a value against the allowed limits for this property.
 * return 0 if value is OK, else -1
 */
static int checkValueLimits(guiPID property, int value)
{
  int retval;

  retval = -1;                  /* assume failure */
  switch (property) {
  case GPID_COPIES:
    if ((value > 0) && (value < 100)) {
      retval = 0;
    }
    break;
  case GPID_PAPERSIZE:
    if (value == GPID_PAPERSIZE_LETTER || value == GPID_PAPERSIZE_A4) {
      retval = 0;
    }
  case GPID_SCALE:
    if ((value >= 25) && (value <= 400)) {
      retval = 0;
    }
    break;
  case GPID_BRIGHTNESS:
    if ((value >= 0) && (value <= 6)) {
      retval = 0;
    }
    break;
  case GPID_CONTRAST:
    if ((value >= -100) && (value <= 100)) {
      retval = 0;
    }
    break;
  case GPID_PAPERTYPE:
    if ((value == GPID_PAPERTYPE_PLAIN) || (value == GPID_PAPERTYPE_PHOTO)) {
      retval = 0;
    }
    break;
  case GPID_QUALITY:
    if ( (value == GPID_QUALITY_DRAFT)
         || (value == GPID_QUALITY_NORMAL)
         || ( value == GPID_QUALITY_BEST) ) {
      retval = 0;
    }
    break;
  case GPID_CYAN:
    if ((value >= -100) && (value <= 100)) {
      retval = 0;
    }
    break;
  case GPID_MAGENTA:
    if ((value >= -100) && (value <= 100)) {
      retval = 0;
    }
    break;
  case GPID_YELLOW:
    if ((value >= -100) && (value <= 100)) {
      retval = 0;
    }
    break;
  case GPID_SEGMENTATION:
    if ((value == GPID_SEGMENTATION_OFF) || (value == GPID_SEGMENTATION_ON)) {
      retval = 0;
    }
    break;
  case GPID_POSTERMODE:
    if ( (value == GPID_POSTERMODE_OFF)
         || (value == GPID_POSTERMODE_2x2)
         || (value == GPID_POSTERMODE_3x3)
         || (value == GPID_POSTERMODE_4x4) ) {
      retval = 0;
    }
    break;
  case GPID_NUP:
    if ( (value == GPID_NUP_1UP) 
         || (value == GPID_NUP_4UP) 
         || (value == GPID_NUP_9UP) 
         || (value == GPID_NUP_16UP) ) {
      retval = 0;
    }
    break;
  case GPID_MODE:
    if ( (value == GPID_MODE_TEXT)
         || (value == GPID_MODE_AUTO)
         || (value == GPID_MODE_PHOTO) ) {
      retval = 0;
    }
    break;
  case GPID_PHOTOSIZE:
    if (0 <= value && value < ne_PhotoSize) {
      retval = 0;
    }
  }
  return (retval);
}

const char *GPMGetName(guiPID property)
{
  switch (property) {
  case GPID_COPIES:
    return ("Copies:");
  case GPID_PAPERSIZE:
    return ("Paper Size:");
  case GPID_SCALE:
    return ("Scale:");
  case GPID_BRIGHTNESS:
    return ("Brightness:");
  case GPID_CONTRAST:
    return ("Contrast:");
  case GPID_PAPERTYPE:
    return ("Paper Type:");
  case GPID_QUALITY:
    return ("Quality:");
  case GPID_CYAN:
    return ("Cyan:");
  case GPID_MAGENTA:
    return ("Magenta:");
  case GPID_YELLOW:
    return ("Yellow:");
  case GPID_SEGMENTATION:
    return ("Segmentation:");
  case GPID_POSTERMODE:
    return ("Poster Mode:");
  case GPID_NUP:
    return ("N-up:");
  case GPID_MODE:
    return ("Mode:");
  case GPID_PHOTOSIZE:
    return ("Photo Size:");
  }
  return ("Unknown");
}

const char *GPMGetDisplayValue(guiPID property)
{
  static char buffer[128];
  int value;
  const char *ptr;

  ptr = NULL;

  /* get value and check against limits */
  value = getDisplayValue(property);
  if (value != PROPVALUE_ERROR && checkValueLimits(property, value) == 0) {
    switch (property) {
    case GPID_COPIES:
      sprintf(buffer, "%d", value);
      ptr = (const char *)buffer;
      break;
    case GPID_PAPERSIZE:
      if (value == GPID_PAPERSIZE_LETTER) {
        ptr = "Letter";
      } else if (value == GPID_PAPERSIZE_A4) {
        ptr = "A4";
      }
      break;
    case GPID_SCALE:
      sprintf(buffer, "%d%%", value);
      ptr = (const char *)buffer;
      break;
    case GPID_BRIGHTNESS:
      if (value >= 3) {
        sprintf(buffer, "+%d%%", (((value - 3) * 1000) + 15)/30);
      } else {
        sprintf(buffer, "%d%%", (((value - 3) * 1000) - 15)/30);
      }
      ptr = (const char *)buffer;
      break;
    case GPID_CONTRAST:
      if (value >= 0) {
        sprintf(buffer, "+%d%%", value);
      } else {
        sprintf(buffer, "%d%%", value);
      }
      ptr = (const char *)buffer;
      break;
    case GPID_PAPERTYPE:
      if (value == GPID_PAPERTYPE_PLAIN) {
        ptr = "Plain";
      } else {
        ptr = "Photo";
      }
      break;
    case GPID_QUALITY:
      if (value == GPID_QUALITY_DRAFT) {
        ptr = "Draft";
      } else if (value == GPID_QUALITY_NORMAL) {
        ptr = "Normal";
      } else if (value == GPID_QUALITY_BEST) {
        ptr = "Best";
      }
      break;
    case GPID_CYAN:
      if (value >= 0) {
        sprintf(buffer, "+%d%%", value);
      } else {
        sprintf(buffer, "%d%%", value);
      }
      ptr = (const char *)buffer;
      break;
    case GPID_MAGENTA:
      if (value >= 0) {
        sprintf(buffer, "+%d%%", value);
      } else {
        sprintf(buffer, "%d%%", value);
      }
      ptr = (const char *)buffer;
      break;
    case GPID_YELLOW:
      if (value >= 0) {
        sprintf(buffer, "+%d%%", value);
      } else {
        sprintf(buffer, "%d%%", value);
      }
      ptr = (const char *)buffer;
      break;
    case GPID_SEGMENTATION:
      if (value == GPID_SEGMENTATION_OFF) {
        ptr = "Off";
      } else if (value == GPID_SEGMENTATION_ON) {
        ptr = "On";
      }
      break;
    case GPID_POSTERMODE:
      if (value == GPID_POSTERMODE_OFF) {
        ptr = "Off";
      } else if (value == GPID_POSTERMODE_2x2) {
        ptr = "2x2";
      } else if (value == GPID_POSTERMODE_3x3) {
        ptr = "3x3";
      } else if (value == GPID_POSTERMODE_4x4) {
        ptr = "4x4";
      }
      break;
    case GPID_NUP:
      if (value == GPID_NUP_1UP) {
        ptr = "1-up";
      } else if (value == GPID_NUP_4UP) {
        ptr = "4-up";
      } else if (value == GPID_NUP_9UP) {
        ptr = "9-up";
      } else if (value == GPID_NUP_16UP) {
        ptr = "16-up";
      }
      break;
    case GPID_MODE:
      if (value == GPID_MODE_TEXT) {
        ptr = "Text";
      } else if (value == GPID_MODE_AUTO) {
        ptr = "Auto";
      } else if (value == GPID_MODE_PHOTO) {
        ptr = "Photo";
      }
      break;
    case GPID_PHOTOSIZE:
      switch (value) {
#ifdef PhotoSize_PHZ8p5x11
      case (PhotoSize_PHZ8p5x11):
        ptr = "8.5x11";
        break;
#endif
#ifdef PhotoSize_PHZA4
      case (PhotoSize_PHZA4):
        ptr = "A4";
        break;
#endif
#ifdef PhotoSize_PHZA5
      case (PhotoSize_PHZA5):
        ptr = "A5";
        break;
#endif
#ifdef PhotoSize_PHZA6
      case (PhotoSize_PHZA6):
        ptr = "A6";
        break;
#endif
#ifdef PhotoSize_PHZHAGAKI
      case (PhotoSize_PHZHAGAKI):
        ptr = "HAGAKI";
        break;
#endif
#ifdef PhotoSize_PHZ2p25x3p25
      case (PhotoSize_PHZ2p25x3p25):
        ptr = "2.25x3.25";
        break;
#endif
#ifdef PhotoSize_PHZ3p5x5
      case (PhotoSize_PHZ3p5x5):
        ptr = "3.5x5";
        break;
#endif
#ifdef PhotoSize_PHZ4x6
      case (PhotoSize_PHZ4x6):
        ptr = "4x6";
        break;
#endif
#ifdef PhotoSize_PHZ5x7
      case (PhotoSize_PHZ5x7):
        ptr = "5x7";
        break;
#endif
#ifdef PhotoSize_PHZ8x10
      case (PhotoSize_PHZ8x10):
        ptr = "8x10";
        break;
#endif
#ifdef PhotoSize_PHZL
      case (PhotoSize_PHZL):
        ptr = "L";
        break;
#endif
#ifdef PhotoSize_PHZ2L
      case (PhotoSize_PHZ2L):
        ptr = "2L";
        break;
#endif
      }
      break;
    }
  }
  if (!ptr) {
    ptr = "Unknown";
  }
  return (ptr);
}

/* Increment the display value; wrap to the lowest legal value
 * if necessary.
 */
void GPMIncrementDisplayValue(guiPID property)
{
  int value;
  int retval;
  
  value = getDisplayValue(property);
  if (value == PROPVALUE_ERROR) {
    /* can't find that property, so just ignore it */
    return;
  }
  value++;
  retval = checkValueLimits(property, value);
  if (retval == 0) {
    setDisplayValue(property, value);
  } else {
    /* value reached the upper limit.  Find lower limit*/
    value--;                    /* original value */
    do {
      value--;
      retval = checkValueLimits(property, value);
    } while (retval == 0);
    value++;                    /* lowest legal value */
    setDisplayValue(property, value);
  }
}

/* Decrement the display value; wrap to the highest legal value
 * if necessary.
 */
void GPMDecrementDisplayValue(guiPID property)
{
  int value;
  int retval;
  
  value = getDisplayValue(property);
  if (value == PROPVALUE_ERROR) {
    /* can't find that property, so just ignore it */
    return;
  }
  value--;
  retval = checkValueLimits(property, value);
  if (retval == 0) {
    setDisplayValue(property, value);
  } else {
    /* value reached the lower limit.  Find lower limit*/
    value++;                    /* original value */
    do {
      value++;
      retval = checkValueLimits(property, value);
    } while (retval == 0);
    value--;                    /* lowest legal value */
    setDisplayValue(property, value);
  }
}

/* Save the display value of a property */
void GPMSaveDisplayValue(guiPID property)
{
  int value;
  
  value = getDisplayValue(property);
  if (value == PROPVALUE_ERROR) {
    return;
  }
  setSavedValue(property, value);
}

/* Restore the display value of a property */
void GPMRestoreDisplayValue(guiPID property)
{
  int value;
  
  value = getSavedValue(property);
  if (value == PROPVALUE_ERROR) {
    return;
  }
  setDisplayValue(property, value);
}

/* Compare the display value with the saved value of a property
 * If the values are the same, return 0, else return 1.
 */
int GPMIsValueModified(guiPID property)
{
  int savedvalue;
  int displayvalue;

  savedvalue = getSavedValue(property);
  if (savedvalue == PROPVALUE_ERROR) {
    return 0;
  }
  displayvalue = getDisplayValue(property);
  if (displayvalue == PROPVALUE_ERROR) {
    return 0;
  }
  if (savedvalue != displayvalue) {
    return (1);
  } else {
    return (0);
  }
}

int GPMGetSavedValue(guiPID property)
{
  int retval;

  retval = getSavedValue(property);

  ASSERT(retval != PROPVALUE_ERROR);
  return (retval);
}


void GPMinit()
{
  /* this implementation does nothing */

  /* Some implementations will copy property values
   * from backing storage into the display and saved values.
   */
}