/* 

 * Motif

 *

 * Copyright (c) 1987-2012, The Open Group. All rights reserved.

 *

 * These libraries and programs are free software; you can

 * redistribute them and/or modify them under the terms of the GNU

 * Lesser General Public License as published by the Free Software

 * Foundation; either version 2 of the License, or (at your option)

 * any later version.

 *

 * These libraries and programs are distributed in the hope that

 * they will be useful, but WITHOUT ANY WARRANTY; without even the

 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR

 * PURPOSE. See the GNU Lesser General Public License for more

 * details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with these librararies and programs; if not, write

 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth

 * Floor, Boston, MA 02110-1301 USA

*/ 

/* 

 * HISTORY

*/ 

#ifdef HAVE_CONFIG_H

#include <config.h>

#endif

#ifdef REV_INFO

#ifndef lint

static char rcsid[] = "$TOG: Mrmwvalues.c /main/12 1999/04/16 09:42:44 mgreess $"

#endif

#endif

/*

*  (c) Copyright 1989, 1990, DIGITAL EQUIPMENT CORPORATION, MAYNARD, MASS. */

/*

 *++

 *  FACILITY:

 *

 *      UIL Resource Manager (URM):

 *

 *  ABSTRACT:

 *

 *	This module contains the routines which implement modifying

 *	a widget (XtSetValues) from UID literals.

 *

 *--

 */

/*

 *

 *  INCLUDE FILES

 *

 */

#include <Mrm/MrmAppl.h>

#include <Mrm/Mrm.h>

/*

 *

 *  TABLE OF CONTENTS

 *

 *	UrmFetchSetValues	Do XtSetValues from UID literals.

 *

 */

/*

 *++

 *

 *  PROCEDURE DESCRIPTION:

 *

 *	UrmFetchSetValues is the internal routine which will

 *	modify a widget via XtSetValues on an argument list whose values

 *	are evaluated literals from a URM hierarchy. 

 *

 *	The args list has ordinary Strings as each tag name. Each value

 *	is interpreted as a String whose value is the index of a literal

 *	to be fetched and evaluated as the actual value. This routine

 *	constructs its own arglist, copying each tag, and setting the

 *	value to the fetched, fixed up, and converted literal value. The

 *	argument is not set in this list (is dropped) if there are any

 *	errors.

 *

 *	This code must also handle pixmaps in the same way that URM does;

 *	it defers converting icons and inserting them in the list

 *	until all the rest of the arglist is done; this allows FG/BG

 *	values to be uncovered in the list for use in the pixmap.

 *

 *  FORMAL PARAMETERS:

 *

 *	hierarchy_id	URM hierarchy from which to read public resources

 *	w		widget to be modified

 *	args		arglist, with literal indexes as values

 *	num_args	# args in args

 *

 *  IMPLICIT INPUTS:

 *

 *  IMPLICIT OUTPUTS:

 *

 *  FUNCTION VALUE:

 *

 *	MrmSUCCESS		operation succeeded

 *	MrmPARTIAL_SUCCESS	at least one fetch suboperation succeeded

 *	other			any error fatal to the operation

 *

 *  SIDE EFFECTS:

 *

 *--

 */

Cardinal 

UrmFetchSetValues (MrmHierarchy		hierarchy_id ,

		   Widget		w ,

		   ArgList		args ,

		   Cardinal		num_args )

{

  /*

   * Local structures

   */

  typedef struct {

    RGMIconImagePtr	icon ;		/* icon to be converted */

    int		pixndx ;	/* argument in arglist (args) */

  } _SavePixmapArg, *_SavePixmapArgPtr ;

  /*

   *  Local variables

   */

  Cardinal		result ;	/* function results */

  int			num_succ = 0;	/* # of successful fetches */

  int			fet_fail = 0;	/* # of failed fetches */

  int			cvt_fail = 0;	/* # failed conversions */

  Cardinal		badfet_res = MrmNOT_FOUND; /* to save NOT_FOUND */

  ArgList		locargs ;	/* local arglist */

  Cardinal		num_used = 0 ;	/* # args used in arglist */

  RGMResourceDescPtr	resptr ;	/* descriptor for literals */

  int			indexlen = 0 ;	/* longest literal length */

  URMPointerListPtr	ptrlist ;	/* to hold scratch contexts */

  int			ndx ;		/* loop index */

  IDBFile		file_id ;	/* file from which literal read */

  MrmType		reptype ;	/* arg value representation type */

  long			val ;		/* value as immediate or pointer */

  int			vec_count ;	/* number of items in val if vector */

  int			vec_size ;

  _SavePixmapArg	pixargs[10] ;	/* to save pixmap args */

  Cardinal		pixargs_cnt = 0 ;  /* # pixargs saved */

  _SavePixmapArgPtr	savepix ;	/* current saved pixmap entry */

  Screen		*screen ;	/* screen for pixmaps */

  Display		*display ;	/* display for pixmaps */

  Pixel			fgint = (Pixel) -1 ; /* fg for pixmaps. */

  Pixel			bgint = (Pixel) -1 ; /* background for pixmaps */

  Pixmap		pixmap ;	/* pixmap created from icon */

  Boolean		swap_needed = FALSE; 

  /*

   * Create local arglist and pointer list for contexts.

   */

  locargs = (ArgList) XtMalloc (num_args*sizeof(Arg)) ;

  UrmPlistInit (num_args, &ptrlist) ;

  /*

   * Find the longest literal index, and allocate a resource descriptor

   * which can hold it. Set the fixed fields of the descriptor.

   */

  for ( ndx=0 ; ndx

    indexlen = MAX (indexlen, strlen((char*)args[ndx].value)) ;

  /*

   * Create a resource descriptor which can be reused to fetch each literal

   */

  resptr = (RGMResourceDescPtr) XtMalloc (sizeof(RGMResourceDesc)+indexlen) ;

  resptr->access = URMaPublic ;

  resptr->type = URMrIndex ;

  resptr->res_group = URMgLiteral ;

  resptr->cvt_type = URMtNul ;

  /*

   * Loop through all the entries in the given arglist. Copy each tag into

   * the local arglist. Create a new context to hold the literal, then

   * try to read it from the hierarchy.

   */

  for ( ndx=0 ; ndx

    {

      locargs[num_used].name = args[ndx].name ;

      strcpy (resptr->key.index, (char*)args[ndx].value) ;

      result = Urm__CW_ReadLiteral (resptr, hierarchy_id, NULL,

				    ptrlist, &reptype, &val, &vec_count, 

				    &file_id, &vec_size) ;

      if ( result == MrmSUCCESS )

	num_succ += 1;

      else

	{

	  fet_fail += 1;

	  if ( result != MrmNOT_FOUND )

	    badfet_res = result;

	  continue;

	}

      /*

       * Fix up and perform conversion on the value. If this succeeds, put it

       * in the local arglist. Special casing is required for some types,

       * particularly icons.

       *

       * Type conversion for some ASCIZ strings is also provided as a V1

       * compatibility feature.

       */

      switch ( reptype )

        {

	case MrmRtypeIconImage:

	  savepix = &pixargs[pixargs_cnt] ;

	  savepix->icon = (RGMIconImagePtr) val ;

	  savepix->pixndx = ndx ;

	  pixargs_cnt += 1 ;

	  continue ;

	case MrmRtypeFontList:

	  /* Check for 1.1 version and malloc new fontlist if necessary. */

	  if (strcmp(file_id->db_version, URM1_1version) <= 0)

	    {

	      int count = ((OldRGMFontListPtr)val)->count;

	      RGMFontListPtr fontlist = (RGMFontListPtr)

		XtMalloc(sizeof(RGMFontList) +

			 (sizeof(RGMFontItem) * (count - 1)));

	      result = Urm__CW_FixupValue((long)fontlist, reptype, 

					  (XtPointer)val, file_id,

					  &swap_needed);

	      XtFree((char *)val);

	      val = (long)fontlist;

	    }

	  else

	    result = Urm__CW_FixupValue (val, reptype, (XtPointer)val, 

					 file_id, &swap_needed) ;

	default:

	  result = 

	    Urm__CW_FixupValue (val, reptype, (XtPointer)val, file_id,

				&swap_needed) ;

	  if ( result != MrmSUCCESS )

	    {

	      num_succ -= 1;

	      cvt_fail += 1;

	      continue;

	    }

	  if (XtIsWidget(w))

	    display = XtDisplay(w);

	  else

	    display = XtDisplay(XtParent(w));

	  result = Urm__CW_ConvertValue (XtParent(w), &val, reptype, (MrmType)0,

					 display, hierarchy_id,  NULL) ;

	  if ( result != MrmSUCCESS )

	    {

	      num_succ -= 1;

	      cvt_fail += 1;

	      continue;

	    }

	  locargs[num_used].value = (XtArgVal)val ;

	  num_used += 1 ;

	  break ;

        }

      /*

       * Do any processing based on specific arguments (after conversion):

       *	- retain FG/BG info

       */

      switch ( reptype )

	{

	case MrmRtypeColor:

	  if ( strcmp(args[ndx].name,XmNforeground) == 0 )

	    fgint = val;

	  else if ( strcmp (args[ndx].name,XmNbackground) == 0 )

	    bgint = val;

	  break ;

        }

    }	/* end loop */

  /*

   * Now set any pixmap arguments. This requires finding the display, screen,

   * foreground, and background values for this widget. These values are

   * available from the parent widget and the arglist.

   */

  if ( pixargs_cnt > 0 )

    {

      Urm__CW_GetPixmapParms (w, &screen, &display, &fgint, &bgint) ;

      for ( ndx=0,savepix=pixargs ; ndx

        {

	  result = UrmCreatePixmap (savepix->icon, screen, display,

				    (Pixel)fgint, (Pixel)bgint, &pixmap, w) ;

	  if ( result != MrmSUCCESS )

	    {

	      num_succ -= 1;

	      cvt_fail += 1;

	      continue;

	    }

	  locargs[num_used].name = args[savepix->pixndx].name ;

	  locargs[num_used].value = (XtArgVal) pixmap ;

	  num_used += 1 ;

        }

    }

  /*

   * arglist creation complete. Modify the widget if we have succeeded in

   * fetching any values. Deallocate resources.

   */

  if ( num_used > 0 )

    XtSetValues (w, locargs, num_used) ;

  XtFree ((char*)locargs) ;

  XtFree ((char*)resptr) ;

  for ( ndx=0 ; ndx

    UrmFreeResourceContext ((URMResourceContextPtr)UrmPlistPtrN(ptrlist,ndx)) ;

  UrmPlistFree (ptrlist) ;

  /*

   * Result depends on number of successes vs. number of failurs

   */

  if ( num_succ > 0 )

    {

      if ( fet_fail==0 && cvt_fail == 0 )

	return MrmSUCCESS;

      else

	return MrmPARTIAL_SUCCESS;

    }

  if ( fet_fail > 0 )

    return badfet_res;

  else

    return MrmFAILURE;

}