resources.c

安装DDD之前

    },
    {
	XmNiconImageForeground, XmCIconImageForeground, XmRPixel,
	sizeof(Pixel), Offset(icon_image_foreground),
	XmRCallProc, (XtPointer)_WmIconImageFDefault
    },
    {
	XmNiconImageTopShadowColor, XmCIconImageTopShadowColor, XmRPixel,
	sizeof(Pixel), Offset(icon_image_top_shadow_color),
	XmRCallProc, (XtPointer)_WmIconImageTSCDefault
    },
    {
	XmNiconImageTopShadowPixmap, XmCIconImageTopShadowPixmap, XmRPixmap,
	sizeof(Pixmap), Offset(icon_image_top_shadow_pixmap),
	XmRCallProc, (XtPointer)_WmIconImageTSPDefault
    },
    {
	XmNmatteBackground, XmCMatteBackground, XmRPixel,
	sizeof(Pixel), Offset(matte_background),
	XmRCallProc, (XtPointer)_WmMatteBDefault
    },
    {
	XmNmatteBottomShadowColor, XmCMatteBottomShadowColor, XmRPixel,
	sizeof(Pixel), Offset(matte_bottom_shadow_color),
	XmRCallProc, (XtPointer)_WmMatteBSCDefault
    },
    {
	XmNmatteBottomShadowPixmap, XmCMatteBottomShadowPixmap, XmRPixmap,
	sizeof(Pixmap), Offset(matte_bottom_shadow_pixmap),
	XmRCallProc, (XtPointer)_WmMatteBSPDefault
    },
    {
	XmNmatteForeground, XmCMatteForeground, XmRPixel,
	sizeof(Pixel), Offset(matte_foreground),
	XmRCallProc, (XtPointer)_WmMatteFDefault
    },
    {
	XmNmatteTopShadowColor, XmCMatteTopShadowColor, XmRPixel,
	sizeof(Pixel), Offset(matte_top_shadow_color),
	XmRCallProc, (XtPointer)_WmMatteTSCDefault
    },
    {
	XmNmatteTopShadowPixmap, XmCMatteTopShadowPixmap, XmRPixmap,
	sizeof(Pixmap), Offset(matte_top_shadow_pixmap),
	XmRCallProc, (XtPointer)_WmMatteTSPDefault
    },
    {
	XmNmatteWidth, XmCMatteWidth, XmRDimension,
	sizeof(Dimension), Offset(matte_width),
	XmRImmediate, (XtPointer)0
    },
    {
	XmNmaximumClientSize, XmCMaximumClientSize, XmRWmSize,
	sizeof(Size), Offset(maximum_client_size),
	XmRCallProc, (XtPointer)NULL
    },
    {
	XmNuseClientIcon, XmCUseClientIcon, XmRBoolean,
	sizeof(Boolean), Offset(use_client_icon),
	XmRImmediate, (XtPointer)False
    },
    {
	XmNusePPosition, XmCUsePPosition, XmRWmUsePPosition,
	sizeof(unsigned char), Offset(use_p_position),
	XmRString, (XtPointer)"nonzero"
    },
    {
	XmNwindowMenu, XmCWindowMenu, XmRString,
	sizeof(String), Offset(window_menu),
	XmRImmediate, (XtPointer)DEFAULT_WIN_MENU_NAME
    }
};

/*
 * Syntax:
 * "Mwm*[component_name]*resource_name: resource_value"
 *
 * BTW, just in case some copyrighters come along:  I got the function names
 * by runnings "strings" on mwm on Solaris...
 */
#undef Offset
#define Offset(field)	XtOffsetOf(ComponentInfo, field)
static XtResource mwm_component_resources[] =
{
    {
	XmNbackground, XmCBackground, XmRPixel,
	sizeof(Pixel), Offset(background),
	XmRCallProc, (XtPointer)_WmBackgroundDefault
    },
    {
	XmNforeground, XmCForeground, XmRPixel,
	sizeof(XFontStruct *), Offset(foreground),
	XmRCallProc, (XtPointer)_WmForegroundDefault
    },
    {
	XmNbackgroundPixmap, XmCBackgroundPixmap, XmRPixmap,
	sizeof(Pixmap), Offset(background_pixmap),
	XmRCallProc, (XtPointer)_WmBackgroundPixmapDefault
    },
    {
	XmNbottomShadowColor, XmCBottomShadowColor, XmRPixel,
	sizeof(Pixel), Offset(bottom_shadow_color),
	XmRCallProc, (XtPointer)_WmBottomShadowColorDefault
    },
    {
	XmNbottomShadowPixmap, XmCBottomShadowPixmap, XmRPixmap,
	sizeof(Pixmap), Offset(bottom_shadow_pixmap),
	XmRCallProc, (XtPointer)_WmBottomShadowPixmapDefault
    },
    {
	XmNfontList, XmCFontList, XmRFontList,
	sizeof(XmFontList), Offset(font_list),
	XmRString, (XtPointer)"fixed"
    },
    {
	XmNsaveUnder, XmCSaveUnder, XmRBoolean,
	sizeof(Boolean), Offset(save_under),
	XmRImmediate, (XtPointer)False
    },
    {
	XmNtopShadowColor, XmCTopShadowColor, XmRPixel,
	sizeof(Pixel), Offset(top_shadow_color),
	XmRCallProc, (XtPointer)_WmTopShadowColorDefault
    },
    {
	XmNtopShadowPixmap, XmCTopShadowPixmap, XmRPixmap,
	sizeof(Pixmap), Offset(top_shadow_pixmap),
	XmRCallProc, (XtPointer)_WmTopShadowPixmapDefault
    }
};

/*
 * frame/icon resources
 */
#undef Offset
#define Offset(field)	XtOffsetOf(ComponentInfo, field)
static XtResource mwm_component_fi_resources[] =
{
    {
	XmNactiveBackground, XmCBackground, XmRPixel,
	sizeof(Pixel), Offset(active_background),
	XmRCallProc, (XtPointer)_WmABackgroundDefault
    },
    {
	XmNactiveForeground, XmCBackground, XmRPixel,
	sizeof(Pixel), Offset(active_foreground),
	XmRCallProc, (XtPointer)_WmAForegroundDefault
    },
    {
	XmNactiveBottomShadowColor, XmCBackground, XmRPixel,
	sizeof(Pixel), Offset(active_bottom_shadow_color),
	XmRCallProc, (XtPointer)_WmABottomShadowColorDefault
    },
    {
	XmNactiveBottomShadowPixmap, XmCBottomShadowPixmap, XmRPixmap,
	sizeof(Pixmap), Offset(active_bottom_shadow_pixmap),
	XmRImmediate, (XtPointer)XmUNSPECIFIED_PIXMAP
    },
    {
	XmNactiveTopShadowColor, XmCBackground, XmRPixel,
	sizeof(Pixel), Offset(active_top_shadow_color),
	XmRCallProc, (XtPointer)_WmATopShadowColorDefault
    },
    {
	XmNactiveBackgroundPixmap, XmCBackgroundPixmap, XmRPixmap,
	sizeof(Pixmap), Offset(active_background_pixmap),
	XmRCallProc, (XtPointer)_WmABackgroundPixmapDefault
    },
    {
	XmNactiveTopShadowPixmap, XmCTopShadowPixmap, XmRPixmap,
	sizeof(Pixmap), Offset(active_top_shadow_pixmap),
	XmRCallProc, (XtPointer)_WmATopShadowPixmapDefault
    }
};

static char *
  colormap_focus_policies[] =
{
    "explicit",
    "pointer",
    "keyboard",
    NULL
};

static char *
  client_decorations[] =
{
    "all",
    "border",
    "resize",
    "title",
    "menu",
    "minimize",
    "maximize",
    NULL
};

static char *
  client_functions[] =
{
    "all",
    "resize",
    "move",
    "minimize",
    "maximize",
    "close",
    NULL
};

static char *
  icon_decorations[] =
{
    "activelabel",
    "image",
    "label",
    NULL
};

static char *
  icon_placements[] =
{
    "top",
    "bottom",
    "left",
    "right",
    "tight",
    NULL
};

static char *
  keyboard_focus_policies[] =
{
    "explicit",
    "pointer",
    NULL
};

static char *
  show_feedback[] =
{
    "all",
    "behavior",
    "kill",
    "move",
    "placement",
    "quit",
    "resize",
    "restart",
    NULL
};

static char *
  use_p_positions[] =
{
    "on",
    "off",
    "nonzero",
    NULL
};

static char *
  client_flags[] =
{
    "sticky",
    "circulate_skip",
    "start_iconic",
    "list_skip",
    NULL
};

static Boolean
WmCvtStringToCDecor(Display *dpy, XrmValuePtr args, Cardinal *num_args,
		    XrmValuePtr from, XrmValuePtr to, XtPointer *data)
{
    static long val;
    char *ptr;
    int i;
    Boolean reverse = False;

    if (*num_args != 0)
    {
	XtWarningMsg("wrongParameters", "cvtStringToCDecor",
		     "XmToolkitError", "String to Client Decorations"
		     " conversion needs no extra arguments",
		     (String *)NULL, (Cardinal *)NULL);
    }

    ptr = ((char *)(from->addr));

    if (strcmp(ptr, "all") == 0)
    {
	val = MWM_DECOR_BORDER | MWM_DECOR_RESIZEH | MWM_DECOR_TITLE |
	    MWM_DECOR_MENU | MWM_DECOR_MAXIMIZE | MWM_DECOR_MINIMIZE;

	if (to->addr == NULL)
	{
	    to->addr = (XPointer)&val;
	    to->size = sizeof(long);
	    return True;
	}
	else if (to->size >= sizeof(long))
	{
	    *((long *)to->addr) = val;
	    to->size = sizeof(long);
	    return True;
	}
	else
	{
	    XtDisplayStringConversionWarning(dpy, (char *)from->addr,
					     XmRWmCDecor);
	    return False;
	}
    }

    if (strcmp(ptr, "none") == 0)
    {
	val = 0;
	if (to->addr == NULL)
	{
	    to->addr = (XPointer)&val;
	    to->size = sizeof(long);
	    return True;
	}
	else if (to->size >= sizeof(long))
	{
	    *((long *)to->addr) = val;
	    to->size = sizeof(long);
	    return True;
	}
	else
	{
	    XtDisplayStringConversionWarning(dpy, (char *)from->addr,
					     XmRWmCDecor);
	    return False;
	}
    }

    if (*ptr == '-')
    {
	val = MWM_DECOR_BORDER | MWM_DECOR_RESIZEH | MWM_DECOR_TITLE |
	    MWM_DECOR_MENU | MWM_DECOR_MAXIMIZE | MWM_DECOR_MINIMIZE;
	reverse = True;
    }
    else
	val = 0;

    for (i = 0; client_decorations[i] != NULL; i++)
    {
	if (strstr(ptr, client_decorations[i]) != NULL)
	{
	    if (reverse)
		val &= ~(1L << i);
	    else
		val |= (1L << i);
	}
    }
    if (to->addr == NULL)
    {
	to->addr = (XPointer)&val;
	to->size = sizeof(long);
	return True;
    }
    else if (to->size >= sizeof(long))
    {
	*((long *)to->addr) = val;
	to->size = sizeof(long);
	return True;
    }
    else
    {
	XtDisplayStringConversionWarning(dpy, (char *)from->addr,
					 XmRWmCDecor);
	return False;
    }
}

static Boolean
WmCvtStringToCFocus(Display *dpy, XrmValuePtr args, Cardinal *num_args,
		    XrmValuePtr from, XrmValuePtr to, XtPointer *data)
{
    static unsigned char val;
    char *ptr;
    int i;

    if (*num_args != 0)
    {
	XtWarningMsg("wrongParameters", "cvtStringToCFocus",
		     "XmToolkitError", "String to Colormap Focus Policy"
		     " conversion needs no extra arguments",
		     (String *)NULL, (Cardinal *)NULL);
    }

    ptr = ((char *)(from->addr));

    for (i = 0; colormap_focus_policies[i] != NULL; i++)
    {
	if (strcmp(ptr, colormap_focus_policies[i]) == 0)
	{
	    val = i;
	    if (to->addr == NULL)
	    {
		to->addr = (XPointer)&val;
		to->size = sizeof(unsigned char);
		return True;
	    }
	    else if (to->size >= sizeof(unsigned char))
	    {
		*((unsigned char *)to->addr) = val;
		to->size = sizeof(unsigned char);
		return True;
	    }
	    else
	    {
		XtDisplayStringConversionWarning(dpy, (char *)from->addr,
						 XmRWmCFocus);
		return False;
	    }
	}
    }
    XtDisplayStringConversionWarning(dpy, (char *)from->addr, XmRWmCFocus);
    return False;
}

static Boolean
WmCvtStringToCFunc(Display *dpy, XrmValuePtr args, Cardinal *num_args,
		   XrmValuePtr from, XrmValuePtr to, XtPointer *data)
{
    static long val;
    char *ptr;
    int i;
    Boolean reverse = False;

    if (*num_args != 0)
    {
	XtWarningMsg("wrongParameters", "cvtStringToCFunc",
		     "XmToolkitError", "String to Client Functions"
		     " conversion needs no extra arguments",
		     (String *)NULL, (Cardinal *)NULL);
    }

    ptr = ((char *)(from->addr));

    if (strcmp(ptr, "all") == 0)
    {
	val = MWM_FUNC_RESIZE | MWM_FUNC_MOVE | MWM_FUNC_MINIMIZE |
	    MWM_FUNC_MAXIMIZE | MWM_FUNC_CLOSE;
	if (to->addr == NULL)
	{
	    to->addr = (XPointer)&val;
	    to->size = sizeof(long);
	    return True;
	}
	else if (to->size >= sizeof(long))
	{
	    *((long *)to->addr) = val;
	    to->size = sizeof(long);
	    return True;
	}
	else
	{
	    XtDisplayStringConversionWarning(dpy, (char *)from->addr,
					     XmRWmCFunc);
	    return False;
	}
    }

    if (strcmp(ptr, "none") == 0)
    {
	val = 0;
	if (to->addr == NULL)
	{
	    to->addr = (XPointer)&val;
	    to->size = sizeof(long);
	    return True;
	}
	else if (to->size >= sizeof(long))
	{
	    *((long *)to->addr) = val;
	    to->size = sizeof(long);
	    return True;
	}
	else
	{
	    XtDisplayStringConversionWarning(dpy, (char *)from->addr,
					     XmRWmCFunc);
	    return False;
	}
    }

    if (*ptr == '-')
    {
	val = MWM_FUNC_RESIZE | MWM_FUNC_MOVE | MWM_FUNC_MINIMIZE |
	    MWM_FUNC_MAXIMIZE | MWM_FUNC_CLOSE;
	reverse = True;
    }
    else
	val = 0;

    for (i = 0; client_functions[i] != NULL; i++)
    {
	if (strstr(ptr, client_functions[i]) != NULL)
	{
	    if (reverse)
		val &= ~(1L << i);
	    else
		val |= (1L << i);
	}
    }
    if (to->addr == NULL)
    {
	to->addr = (XPointer)&val;
	to->size = sizeof(long);
	return True;
    }
    else if (to->size >= sizeof(long))
    {
	*((long *)to->addr) = val;
	to->size = sizeof(long);
	return True;
    }
    else
    {
	XtDisplayStringConversionWarning(dpy, (char *)from->addr,
					 XmRWmCFunc);
	return False;
    }
}

static Boolean
WmCvtStringToCFlags(Display *dpy, XrmValuePtr args, Cardinal *num_args,
		    XrmValuePtr from, XrmValuePtr to, XtPointer *data)
{
    static long val;
    char *ptr;
    int i;

    if (*num_args != 0)
    {
	XtWarningMsg("wrongParameters", "cvtStringToCFlags",
		     "XmToolkitError", "String to Client Flags"
		     " conversion needs no extra arguments",
		     (String *)NULL, (Cardinal *)NULL);
    }

    ptr = ((char *)(from->addr));

    if (strcmp(ptr, "all") == 0)
    {
	val = STICKY | CIRCULATESKIP | STARTICONIC | WINDOWLISTSKIP;
	if (to->addr == NULL)
	{
	    to->addr = (XPointer)&val;
	    to->size = sizeof(long);
	    return True;
	}
	else if (to->size >= sizeof(long))
	{
	    *((long *)to->addr) = val;
	    to->size = sizeof(long);
	    return True;
	}
	else
	{
	    XtDisplayStringConversionWarning(dpy, (char *)from->addr,
					     XmRWmCFlags);
	    return False;
	}
    }

    if (strcmp(ptr, "none") == 0)
    {
	val = 0;
	if (to->addr == NULL)
	{
	    to->addr = (XPointer)&val;
	    to->size = sizeof(long);
	    return True;
	}
	else if (to->size >= sizeof(long))
	{
	    *((long *)to->addr) = val;
	    to->size = sizeof(long);
	    return True;
	}
	else
	{
	    XtDisplayStringConversionWarning(dpy, (char *)from->addr,
					     XmRWmCFlags);
	    return False;
	}
    }

    for (i = 0; client_flags[i] != NULL; i++)
    {
	if (strstr(ptr, client_flags[i]) != NULL)
	{
	    val |= (1L << i);
	}
    }
    if (to->addr == NULL)
    {