resources.c

安装DDD之前

	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;
    }
}

static Boolean
WmCvtStringToIDecor(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", "cvtStringToIDecor",
		     "XmToolkitError", "String to Icon Decorations"
		     " conversion needs no extra arguments",
		     (String *)NULL, (Cardinal *)NULL);
    }

    val = 0;
    ptr = ((char *)(from->addr));
    for (i = 0; icon_decorations[i] != NULL; i++)
    {
	if (strstr(ptr, icon_decorations[i]) != 0)
	{
	    val |= (1L << i);
	}
    }
    if (val == 0)
    {
	XtDisplayStringConversionWarning(dpy, (char *)from->addr, XmRWmIPlace);
	return False;
    }
    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;
    }
}

static Boolean
WmCvtStringToIPlace(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", "cvtStringToIPlace",
		     "XmToolkitError", "String to Icon Placement"
		     " conversion needs no extra arguments",
		     (String *)NULL, (Cardinal *)NULL);
    }

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

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

static Boolean
WmCvtStringToKFocus(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", "cvtStringToKFocus",
		     "XmToolkitError", "String to Keyboard Focus Policy"
		     " conversion needs no extra arguments",
		     (String *)NULL, (Cardinal *)NULL);
    }

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

    for (i = 0; keyboard_focus_policies[i] != NULL; i++)
    {
	if (strcmp(ptr, keyboard_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,
						 XmRWmKFocus);
		return False;
	    }
	}
    }
    XtDisplayStringConversionWarning(dpy, (char *)from->addr, XmRWmKFocus);
    return False;
}

static Boolean
WmCvtStringToShowFeedback(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", "cvtStringToShowFeedback",
		     "XmToolkitError", "String to Show Feedback"
		     " conversion needs no extra arguments",
		     (String *)NULL, (Cardinal *)NULL);
    }

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

    if (strcmp(ptr, "all") == 0)
    {
	val = MWM_FEEDBACK_BEHAVIOR | MWM_FEEDBACK_KILL | MWM_FEEDBACK_MOVE |
	    MWM_FEEDBACK_PLACEMENT | MWM_FEEDBACK_QUIT | MWM_FEEDBACK_RESIZE |
	    MWM_FEEDBACK_RESTART;
	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,
					     XmRWmShowFeedback);
	    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,
					     XmRWmShowFeedback);
	    return False;
	}
    }

    if (*ptr == '-')
    {
	val = MWM_FEEDBACK_BEHAVIOR | MWM_FEEDBACK_KILL | MWM_FEEDBACK_MOVE |
	    MWM_FEEDBACK_PLACEMENT | MWM_FEEDBACK_QUIT | MWM_FEEDBACK_RESIZE |
	    MWM_FEEDBACK_RESTART;
	reverse = True;
    }
    else
	val = 0;

    for (i = 0; show_feedback[i] != NULL; i++)
    {
	if (strstr(ptr, show_feedback[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,
					 XmRWmShowFeedback);
	return False;
    }
}

static Boolean
WmCvtStringToSize(Display *dpy, XrmValuePtr args, Cardinal *num_args,
		  XrmValuePtr from, XrmValuePtr to, XtPointer *data)
{
    static Size val;
    char *ptr;

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

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

    memset((void *)&val, 0, sizeof(Size));
    if (sscanf(ptr, "%hdx%hd", &val.width, &val.height) == 2)
    {
	if (to->addr == NULL)
	{
	    to->addr = (XPointer)&val;
	    to->size = sizeof(Size);
	    return True;
	}
	else if (to->size >= sizeof(Size))
	{
	    *((Size *)to->addr) = val;
	    to->size = sizeof(Size);
	    return True;
	}
	else
	{
	    XtDisplayStringConversionWarning(dpy, (char *)from->addr,
					     XmRWmSize);
	    return False;
	}
    }
    XtDisplayStringConversionWarning(dpy, (char *)from->addr, XmRWmSize);
    return False;
}

static Boolean
WmCvtStringToUsePPosition(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", "cvtStringToUsePPosition",
		     "XmToolkitError", "String to Use PPosition"
		     " conversion needs no extra arguments",
		     (String *)NULL, (Cardinal *)NULL);
    }

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

    for (i = 0; use_p_positions[i] != NULL; i++)
    {
	if (strcmp(ptr, use_p_positions[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,
						 XmRWmUsePPosition);
		return False;
	    }
	}
    }
    XtDisplayStringConversionWarning(dpy, (char *)from->addr, XmRWmUsePPosition);
    return False;
}

/*
 * get resources for a client window
 */
void
RES_GetClientDefaults(ScreenInfo *scr, MwmWindow *tmp_win,
		      char *name_s, char *class_s)
{
    working_base = tmp_win;
    rscr = scr;
    XtGetSubresources(toplevel, (XtPointer)tmp_win,
		      name_s, class_s,
		      mwm_client_resources,
		      XtNumber(mwm_client_resources), NULL, 0);
}

void
RES_Initialize(void)
{
    XmRegisterConverters();

    XtSetTypeConverter(XmRString,
		       XmRWmCDecor,
		       WmCvtStringToCDecor,
		       (XtConvertArgList)NULL,
		       0,
		       XtCacheAll,
		       NULL);

    XtSetTypeConverter(XmRString,
		       XmRWmCFocus,
		       WmCvtStringToCFocus,
		       (XtConvertArgList)NULL,
		       0,
		       XtCacheAll,
		       NULL);

    XtSetTypeConverter(XmRString,
		       XmRWmCFunc,
		       WmCvtStringToCFunc,
		       (XtConvertArgList)NULL,
		       0,
		       XtCacheAll,
		       NULL);

    XtSetTypeConverter(XmRString,
		       XmRWmIDecor,
		       WmCvtStringToIDecor,
		       (XtConvertArgList)NULL,
		       0,
		       XtCacheAll,
		       NULL);

    XtSetTypeConverter(XmRString,
		       XmRWmIPlace,
		       WmCvtStringToIPlace,
		       (XtConvertArgList)NULL,
		       0,
		       XtCacheAll,
		       NULL);

    XtSetTypeConverter(XmRString,
		       XmRWmKFocus,
		       WmCvtStringToKFocus,
		       (XtConvertArgList)NULL,
		       0,
		       XtCacheAll,
		       NULL);

    XtSetTypeConverter(XmRString,
		       XmRWmShowFeedback,
		       WmCvtStringToShowFeedback,
		       (XtConvertArgList)NULL,
		       0,
		       XtCacheAll,
		       NULL);

    XtSetTypeConverter(XmRString,
		       XmRWmSize,
		       WmCvtStringToSize,
		       (XtConvertArgList)NULL,
		       0,
		       XtCacheAll,
		       NULL);

    XtSetTypeConverter(XmRString,
		       XmRWmUsePPosition,
		       WmCvtStringToUsePPosition,
		       (XtConvertArgList)NULL,
		       0,
		       XtCacheAll,
		       NULL);

    XtSetTypeConverter(XmRString,
		       XmRWmCFlags,
		       WmCvtStringToCFlags,
		       (XtConvertArgList)NULL,
		       0,
		       XtCacheAll,
		       NULL);

    XtGetApplicationResources(toplevel, (XtPointer)&Mwm,
			      mwm_resources, XtNumber(mwm_resources), NULL, 0);
}

/*
 * get the resources for each screen
 */
void
RES_GetScreenDefaults(ScreenInfo *scr)
{
    rscr = scr;
#if 0
    /*FIXME: do we need this here? A.R.*/
    working_base = scr;
#endif
    XtGetSubresources(toplevel, (XtPointer)scr,
                      scr->screen_name, scr->screen_name,
                      mwm_screen_resources,
                      XtNumber(mwm_screen_resources), NULL, 0);
}

/*
 * get the resources for the components in each screen
 */
void
RES_GetComponentDefaults(ScreenInfo *scr)
{
    Widget client;

    /*
     * MLM: OK, seems the resource manager won't pay attention to me if
     * I ask it to find recursive structures.  This is a hack, and I'd
     * appreciate it if someone would correct the name/class values so
     * I don't have to do this.
     */
    rscr = scr;
    working_base = &(scr->components[MWM_MENU]);
    scr->components[MWM_MENU].type = MWM_MENU;
    XtGetSubresources(toplevel, (XtPointer)&(scr->components[MWM_MENU]),
		      "menu", "menu",
		      mwm_component_resources,
		      XtNumber(mwm_component_resources), NULL, 0);

    working_base = &(scr->components[MWM_FEEDBACK]);
    scr->components[MWM_FEEDBACK].type = MWM_FEEDBACK;
    XtGetSubresources(toplevel, (XtPointer)&(scr->components[MWM_FEEDBACK]),
		      "feedback", "feedback",
		      mwm_component_resources,
		      XtNumber(mwm_component_resources), NULL, 0);

    working_base = &(scr->components[MWM_PAGER]);
    scr->components[MWM_PAGER].type = MWM_PAGER;
    XtGetSubresources(toplevel, (XtPointer)&(scr->components[MWM_PAGER]),
		      "pager", "pager",
		      mwm_component_resources,
		      XtNumber(mwm_component_resources), NULL, 0);

    working_base = &(scr->components[MWM_ICON]);
    scr->components[MWM_ICON].type = MWM_ICON;
    XtGetSubresources(toplevel, (XtPointer)&(scr->components[MWM_ICON]),
		      "icon", "icon",
		      mwm_component_resources,
		      XtNumber(mwm_component_resources), NULL, 0);
    XtGetSubresources(toplevel, (XtPointer)&(scr->components[MWM_ICON]),
		      "icon", "icon",
		      mwm_component_fi_resources,
		      XtNumber(mwm_component_fi_resources), NULL, 0);

    client = XtVaCreateWidget("client", (WidgetClass)&objectClassRec,
			      toplevel, NULL);

    working_base = &(scr->components[MWM_TITLE_A]);
    scr->components[MWM_TITLE_A].type = MWM_TITLE_A;
    XtGetSubresources(client, (XtPointer)working_base,
		      "title", "title",
		      mwm_component_resources,
		      XtNumber(mwm_component_resources), NULL, 0);
    XtGetSubresources(client, (XtPointer)working_base,
		      "title", "title",
		      mwm_component_fi_resources,
		      XtNumber(mwm_component_fi_resources), NULL, 0);

    working_base = &(scr->components[MWM_RESIZE_H]);
    scr->components[MWM_RESIZE_H].type = MWM_RESIZE_H;
    XtGetSubresources(client, (XtPointer)working_base,
		      "resizeh", "resizeh",
		      mwm_component_resources,
		      XtNumber(mwm_component_resources), NULL, 0);
    XtGetSubresources(client, (XtPointer)working_base,
		      "resizeh", "resizeh",
		      mwm_component_fi_resources,
		      XtNumber(mwm_component_fi_resources), NULL, 0);

    working_base = &(scr->components[MWM_BORDER]);
    scr->components[MWM_BORDER].type = MWM_BORDER;
    XtGetSubresources(client, (XtPointer)working_base,
		      "border", "border",
		      mwm_component_resources,
		      XtNumber(mwm_component_resources), NULL, 0);
    XtGetSubresources(client, (XtPointer)working_base,
		      "border", "border",
		      mwm_component_fi_resources,
		      XtNumber(mwm_component_fi_resources), NULL, 0);

    working_base = &(scr->components[MWM_MAXIMIZE_B]);
    scr->components[MWM_MAXIMIZE_B].type = MWM_MAXIMIZE_B;
    XtGetSubresources(client, (XtPointer)working_base,
		      "maximizeb", "maximizeb",
		      mwm_component_resources,
		      XtNumber(mwm_component_resources), NULL, 0);
    XtGetSubresources(client, (XtPointer)working_base,
		      "maximizeb", "maximizeb",
		      mwm_component_fi_resources,
		      XtNumber(mwm_component_fi_resources), NULL, 0);

    working_base = &(scr->components[MWM_MINIMIZE_B]);
    scr->components[MWM_MINIMIZE_B].type = MWM_MINIMIZE_B;
    XtGetSubresources(client, (XtPointer)working_base,
		      "minimizeb", "minimizeb",
		      mwm_component_resources,
		      XtNumber(mwm_component_resources), NULL, 0);
    XtGetSubresources(client, (XtPointer)working_base,
		      "minimizeb", "minimizeb",
		      mwm_component_fi_resources,
		      XtNumber(mwm_component_fi_resources), NULL, 0);

    working_base = &(scr->components[MWM_MENU_B]);
    scr->components[MWM_MENU_B].type = MWM_MENU_B;
    XtGetSubresources(client, (XtPointer)working_base,
		      "menub", "menub",
		      mwm_component_resources,
		      XtNumber(mwm_component_resources), NULL, 0);
    XtGetSubresources(client, (XtPointer)working_base,
		      "menub", "menub",
		      mwm_component_fi_resources,
		      XtNumber(mwm_component_fi_resources), NULL, 0);
}