xp_theme.c

linux下电话本所依赖的一些图形库

    case XP_THEME_ELEMENT_EDIT_TEXT:
      switch(state)
        {
        case GTK_STATE_PRELIGHT:
          ret =  ETS_FOCUSED;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  ETS_READONLY;
          break;
        case GTK_STATE_SELECTED:
        case GTK_STATE_ACTIVE:
        default:
          ret =  ETS_NORMAL;
        }
      break;

    case XP_THEME_ELEMENT_SCROLLBAR_H:
    case XP_THEME_ELEMENT_SCROLLBAR_V:
    case XP_THEME_ELEMENT_TROUGH_H:
    case XP_THEME_ELEMENT_TROUGH_V:
      switch(state)
        {
        case GTK_STATE_SELECTED:
        case GTK_STATE_ACTIVE:
          ret =  SCRBS_PRESSED;
          break;
        case GTK_STATE_PRELIGHT:
          ret =  SCRBS_HOT;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  SCRBS_DISABLED;
          break;
        default:
          ret =  SCRBS_NORMAL;
        }
      break;

    case XP_THEME_ELEMENT_ARROW_DOWN:
      switch(state)
        {
        case GTK_STATE_ACTIVE:
          ret =  ABS_DOWNPRESSED;
          break;
        case GTK_STATE_PRELIGHT:
          ret =  ABS_DOWNHOT;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  ABS_DOWNDISABLED;
          break;
        default:
          ret =  ABS_DOWNNORMAL;
        }
      break;

    case XP_THEME_ELEMENT_ARROW_UP:
      switch(state)
        {
        case GTK_STATE_ACTIVE:
          ret =  ABS_UPPRESSED;
          break;
        case GTK_STATE_PRELIGHT:
          ret =  ABS_UPHOT;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  ABS_UPDISABLED;
          break;
        default:
          ret =  ABS_UPNORMAL;
        }
      break;

    case XP_THEME_ELEMENT_ARROW_LEFT:
      switch(state)
        {
        case GTK_STATE_ACTIVE:
          ret =  ABS_LEFTPRESSED;
          break;
        case GTK_STATE_PRELIGHT:
          ret =  ABS_LEFTHOT;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  ABS_LEFTDISABLED;
          break;
        default:
          ret =  ABS_LEFTNORMAL;
        }
      break;

    case XP_THEME_ELEMENT_ARROW_RIGHT:
      switch(state)
        {
        case GTK_STATE_ACTIVE:
          ret =  ABS_RIGHTPRESSED;
          break;
        case GTK_STATE_PRELIGHT:
          ret =  ABS_RIGHTHOT;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  ABS_RIGHTDISABLED;
          break;
        default:
          ret =  ABS_RIGHTNORMAL;
        }
      break;

    case XP_THEME_ELEMENT_CHECKBOX:
    case XP_THEME_ELEMENT_RADIO_BUTTON:
      switch(state)
        {
        case GTK_STATE_SELECTED:
          ret =  CBS_UNCHECKEDPRESSED;
          break;
        case GTK_STATE_PRELIGHT:
          ret =  CBS_UNCHECKEDHOT;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  CBS_UNCHECKEDDISABLED;
          break;
        default:
          ret =  CBS_UNCHECKEDNORMAL;
        }
      break;

    case XP_THEME_ELEMENT_PRESSED_CHECKBOX:
    case XP_THEME_ELEMENT_PRESSED_RADIO_BUTTON:
      switch(state)
        {
        case GTK_STATE_SELECTED:
          ret =  CBS_CHECKEDPRESSED;
          break;
        case GTK_STATE_PRELIGHT:
          ret =  CBS_CHECKEDHOT;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  CBS_CHECKEDDISABLED;
          break;
        default:
          ret =  CBS_CHECKEDNORMAL;
        }
      break;

    case XP_THEME_ELEMENT_DEFAULT_BUTTON:
      switch(state)
        {
        case GTK_STATE_ACTIVE:
          ret =  PBS_PRESSED;
          break;
        case GTK_STATE_PRELIGHT:
          ret =  PBS_HOT;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  PBS_DISABLED;
          break;
        default:
          ret =  PBS_DEFAULTED;
        }
      break;

    case XP_THEME_ELEMENT_SPIN_BUTTON_DOWN:
      switch(state)
        {
        case GTK_STATE_ACTIVE:
          ret =  DNS_PRESSED;
          break;
        case GTK_STATE_PRELIGHT:
          ret =  DNS_HOT;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  DNS_DISABLED;
          break;
        default:
          ret =  DNS_NORMAL;
        }
      break;

    case XP_THEME_ELEMENT_SPIN_BUTTON_UP:
      switch(state)
        {
        case GTK_STATE_ACTIVE:
          ret =  UPS_PRESSED;
          break;
        case GTK_STATE_PRELIGHT:
          ret =  UPS_HOT;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  UPS_DISABLED;
          break;
        default:
          ret =  UPS_NORMAL;
        }
      break;

    case XP_THEME_ELEMENT_TREEVIEW_EXPANDER_OPENED:
      ret = GLPS_OPENED;
      break;

    case XP_THEME_ELEMENT_TREEVIEW_EXPANDER_CLOSED:
      ret = GLPS_CLOSED;
      break;

    case XP_THEME_ELEMENT_PROGRESS_BAR_H:
    case XP_THEME_ELEMENT_PROGRESS_BAR_V:
    case XP_THEME_ELEMENT_PROGRESS_TROUGH_H:
    case XP_THEME_ELEMENT_PROGRESS_TROUGH_V:
      ret = 1;
      break;

	case XP_THEME_ELEMENT_MENU_ITEM:
	case XP_THEME_ELEMENT_MENU_SEPARATOR:
		switch(state) {
			case GTK_STATE_SELECTED:
				ret = MS_SELECTED;
				break;
			case GTK_STATE_INSENSITIVE:
				ret = MS_DEMOTED;
				break;
			default:
				ret = MS_NORMAL;
		}
		break;

    default:
      switch(state)
        {
        case GTK_STATE_ACTIVE:
          ret =  PBS_PRESSED;
          break;
        case GTK_STATE_PRELIGHT:
          ret =  PBS_HOT;
          break;
        case GTK_STATE_INSENSITIVE:
          ret =  PBS_DISABLED;
          break;
        default:
          ret =  PBS_NORMAL;
        }
    }
  return ret;
}

gboolean
xp_theme_draw (GdkWindow *win, XpThemeElement element, GtkStyle *style,
               int x, int y, int width, int height,
               GtkStateType state_type, GdkRectangle *area)
{
  HTHEME theme;
  RECT rect, clip, *pClip;
  int xoff, yoff;
  HDC dc;
  GdkDrawable *drawable;
  int part_state;

  if (! xp_theme_is_drawable (element))
    return FALSE;

  theme = xp_theme_get_handle_by_element(element);
  if (!theme)
    return FALSE;

  /* FIXME: Recheck its function */
  enable_theme_dialog_texture_func(GDK_WINDOW_HWND(win), ETDT_ENABLETAB);

  if (!GDK_IS_WINDOW(win))
    {
      xoff = 0;
      yoff = 0;
      drawable = win;
    }
  else
    {
      gdk_window_get_internal_paint_info(win, &drawable, &xoff, &yoff);
    }

  rect.left = x - xoff;
  rect.top = y - yoff;
  rect.right = rect.left + width;
  rect.bottom = rect.top + height;

  if (area)
    {
      clip.left = area->x - xoff;
      clip.top = area->y - yoff;
      clip.right = clip.left + area->width;
      clip.bottom = clip.top + area->height;

      pClip = &clip;
    }
  else
    {
      pClip = NULL;
    }

  gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
  dc = gdk_win32_hdc_get(drawable, style->dark_gc[state_type], 0);
  if (!dc)
    return FALSE;

  part_state = xp_theme_map_gtk_state(element, state_type);

#ifdef GNATS_HACK
  if (element == XP_THEME_ELEMENT_REBAR_GRIPPER_V
      || element == XP_THEME_ELEMENT_REBAR_GRIPPER_H)
    {
      /* Hack alert: when XP draws a gripper, it does not seem to fill
         up the whole rectangle. It only fills the gripper line
         itself. Therefore we manually fill up the background here
         ourselves. I still have to look into this a bit further, as
         tests with GNAT Programming System show some awkward
         interference between this FillRect and the subsequent
         DrawThemeBackground(). */
      FillRect (dc, &rect, (HBRUSH) (COLOR_3DFACE+1));
    }
#endif

  if (is_theme_partially_transparent_func && draw_theme_parent_background_func &&
  		is_theme_partially_transparent_func(theme, element_part_map[element], part_state))
  {
    draw_theme_parent_background_func(GDK_WINDOW_HWND(win), dc, pClip);
  }

  draw_theme_background_func(theme, dc, element_part_map[element], part_state, &rect, pClip);
  gdk_win32_hdc_release(drawable, style->dark_gc[state_type], 0);

  return TRUE;
}

static gboolean
xp_theme_is_active (void)
{
  gboolean active = FALSE;

  if (is_app_themed_func)
  {
	  active = (*is_app_themed_func) ();

	  if (active && is_theme_active_func)
	    {
	      active = (*is_theme_active_func) ();
		}
  }

  return active;
}

gboolean
xp_theme_is_drawable (XpThemeElement element)
{
 if (xp_theme_is_active ())
  return (xp_theme_get_handle_by_element (element) != NULL);

  return FALSE;
}

gboolean
xp_theme_get_system_font (XpThemeClass klazz, XpThemeFont fontId, LOGFONT *lf)
{
  int themeFont;

  if (get_theme_sys_font_func != NULL)
    {
      HTHEME theme = xp_theme_get_handle_by_class(klazz);
      if (!theme)
        return FALSE;

      switch (fontId)
        {
        case XP_THEME_FONT_CAPTION:
          themeFont = TMT_CAPTIONFONT; break;
        case XP_THEME_FONT_MENU:
          themeFont = TMT_MENUFONT; break;
        case XP_THEME_FONT_STATUS:
          themeFont = TMT_STATUSFONT; break;
        case XP_THEME_FONT_MESSAGE:
        default:
          themeFont = TMT_MSGBOXFONT; break;
        }
      /* if theme is NULL, it will just return the GetSystemFont() value */
      return ((*get_theme_sys_font_func)(theme, themeFont, lf) == S_OK);
    }
  return FALSE;
}

gboolean
xp_theme_get_system_color (XpThemeClass klazz, int colorId, DWORD * pColor)
{
  if (get_theme_sys_color_func != NULL)
    {
      HTHEME theme = xp_theme_get_handle_by_class(klazz);

      /* if theme is NULL, it will just return the GetSystemColor() value */
      *pColor = (*get_theme_sys_color_func)(theme, colorId);
      return TRUE;
    }
  return FALSE;
}

gboolean
xp_theme_get_system_metric (XpThemeClass klazz, int metricId, int * pVal)
{
  if (get_theme_sys_metric_func != NULL)
    {
      HTHEME theme = xp_theme_get_handle_by_class(klazz);

      /* if theme is NULL, it will just return the GetSystemMetrics() value */
      *pVal = (*get_theme_sys_metric_func)(theme, metricId);
      return TRUE;
    }
  return FALSE;
}