Example #1
0
void set_buttons_from_gdb(Widget buttons, string& text)
{
    bool yn = gdb->ends_with_yn(text);

    if (yn)
    {
	if (!gdb_asks_yn)
	    annotate("query");

	gdb_asks_yn = true;
    }
    else if (gdb->isReadyWithPrompt())
    {
	if (gdb_asks_yn)
	    annotate("post-query");

	gdb_asks_yn = false;
	unpost_gdb_yn();
    }

    if (yn && !gdb_keyboard_command)
    {
	// Fetch previous output lines, in case this is a multi-line message.
	String s = XmTextGetString(gdb_w);
	string prompt(s);
	XtFree(s);

	// FIXME: Handle JDB
	char prompt_start = (gdb->type() == XDB ? '>' : '(');

	int pos = prompt.index(prompt_start, -1);
	if (pos >= 0)
	    pos = prompt.index('\n', pos) + 1;
	if (pos == 0)
	    pos = messagePosition;

	XmTextReplace(gdb_w, pos, XmTextGetLastPosition(gdb_w), XMST(""));
	promptPosition = pos;

	prompt = prompt.from(pos);
	if (text.contains('('))
	    prompt += text.before('(', -1); // Don't repeat `(y or n)'
	else
	    prompt += text;

	post_gdb_yn(prompt);
	text = "";
	return;
    }

    if (buttons == 0)
	return;

    static bool last_yn = false;
    if (yn == last_yn)
	return;

    last_yn = yn;

    if (XtIsComposite(buttons))
    {
	set_sensitive(buttons, false);

	WidgetList children   = 0;
	Cardinal num_children = 0;

	XtVaGetValues(buttons,
		      XmNchildren, &children,
		      XmNnumChildren, &num_children,
		      XtPointer(0));

	int i;
	for (i = 0; i < int(num_children); i++)
	    XtManageChild(children[i]);
	for (i = 0; i < int(num_children); i++)
	{
	
	    Widget w = children[i];
	    string name = XtName(w);

	    if (yn == (name == "Yes" || name == "No"))
		XtManageChild(w);
	    else
		XtUnmanageChild(w);
	}

	set_sensitive(buttons, true);
    }
}
Example #2
0
int
get_bill_cycle_db()
{
    XmStringTable str_list;
    XmString str;
    int i=0,num_found;
    int  ret_code;
    BILL_CYCLE_STRUCT bill_cycle_struct;

      memset((char *)&bill_cycle_struct,0,sizeof(BILL_CYCLE_STRUCT));
      dbcmd(dbproc1, " select ");
      dbcmd(dbproc1, " bill_period,");
      dbcmd(dbproc1, " billing_frequency,");
      dbcmd(dbproc1, " ppdd_date,");
      dbcmd(dbproc1, " next_ppdd_date,");
      dbcmd(dbproc1, " statement_date,");
      dbcmd(dbproc1, " cutoff_date,");
      dbcmd(dbproc1, " prep_delay");
      dbcmd(dbproc1, " from BILL_CYCLE ");
      dbcmd(dbproc1, " order by bill_period,billing_frequency,next_ppdd_date ");

      if (safe_dbselect(dbproc1, "BILL_CYCLE", "get_bill_cycle_db"))
      {
        return(FAILURE);
      }

      dbbind(dbproc1,1,NTBSTRINGBIND,256,
          bill_cycle_struct.bill_period);
      dbbind(dbproc1,2,NTBSTRINGBIND,256,
          bill_cycle_struct.billing_frequency);
      dbbind(dbproc1,3,ARB_TYPE_DATELONG,0,
          &(bill_cycle_struct.ppdd_dt));
      dbbind(dbproc1,4,ARB_TYPE_DATELONG,0,
          &(bill_cycle_struct.next_ppdd_dt));
      dbbind(dbproc1,5,ARB_TYPE_DATELONG,0,
          &(bill_cycle_struct.statement_dt));
      dbbind(dbproc1,6,ARB_TYPE_DATELONG,0,
          &(bill_cycle_struct.cutoff_dt));
      dbbind(dbproc1,7,NTBSTRINGBIND,256,
          bill_cycle_struct.prep_delay);

      while ((ret_code = dbnextrow(dbproc1)) == REG_ROW)
      {
          Arbdate_to_date_time(&(bill_cycle_struct.ppdd_dt),
            bill_cycle_struct.ppdd_date, bill_cycle_struct.ppdd_time);
          Arbdate_to_date_time(&(bill_cycle_struct.next_ppdd_dt),
            bill_cycle_struct.next_ppdd_date, bill_cycle_struct.next_ppdd_time);
          Arbdate_to_date_time(&(bill_cycle_struct.statement_dt),
            bill_cycle_struct.statement_date, bill_cycle_struct.statement_time);
          Arbdate_to_date_time(&(bill_cycle_struct.cutoff_dt),
            bill_cycle_struct.cutoff_date, bill_cycle_struct.cutoff_time);
          i++;
          bill_cycle_list =
              (BILL_CYCLE_STRUCT *)realloc(bill_cycle_list,
              i * sizeof(BILL_CYCLE_STRUCT));
          memcpy((char *)&bill_cycle_list[i-1],
          (char *)&bill_cycle_struct,
              sizeof(BILL_CYCLE_STRUCT));
      } /* end of while loop */


      if(check_dbresults(dbproc1, ret_code,
          "BILL_CYCLE",
          "get_bill_cycle_db"))
        return(FAILURE);

      if (i > 0)
      {
        num_found = i;
        str_list = (XmStringTable)XtMalloc(num_found * sizeof (XmString*));
        for (i = 0; i < num_found; i++)
        {
          format_bill_cycle(scratch, &bill_cycle_list[i]);
          str_list[i] = XmStringCreateSimple(scratch);
        }
        XtVaSetValues(bill_cycle_summlist,
          XmNitemCount, num_found,
          XmNitems, str_list, NULL);

        for (i = 0; i < num_found; i++)
          XmStringFree(str_list[i]);
        XtFree((char *)str_list);
      }
      else if (i == 0)
      {
        XtVaSetValues(bill_cycle_summlist,
          XmNitemCount, 0,
          XmNitems, NULL, NULL);
        return(-1);
      }
      return(SUCCESS);
}
Example #3
0
void iupdrvTextConvertLinColToPos(Ihandle* ih, int lin, int col, int *pos)
{
  char* str = XmTextGetString(ih->handle);
  *pos = motTextSetLinColToPosition(str, lin, col);
  XtFree(str);
}
Example #4
0
void
RadarOverlayCB (Widget w, XtPointer client_data, XtPointer xt_call_data )
{
	MetObjectType		*mlist[MAXMETOBJS];
	GuiBackgroundDialogType	*bak;
	WindowObjectType	*wo;
	GlobalDataObjectType	*gd;
	
	char	*text;
	int	index=2;
	int	color;
	int	verbose, iret;

	struct {
	    char	stid[STIDSIZE];
	    char	units[3];
	    BooleanType	display;
	    int		number;
	    float	increment;
	    float	minimum;
	} ring;

	XmPushButtonCallbackStruct *cbs =
	            (XmPushButtonCallbackStruct *) xt_call_data;

	bak = GetGuiBackgroundDialog();

/*
 *	Make sure window object exists.
 */
	wo = GetActiveWindowObject();

	verbose = GetVerboseLevel();
	if( verbose > VERBOSE_0 )
	    printf ( "RadarOverlayCB\n" );
/*
 *	Get radar ring inputs.
 */
	if ( text = XmTextGetString ( GetRringNumberW ( bak ) ) ) {
	    ring.number = atoi ( text );
	    XtFree ( text );
	}

	if ( text = XmTextGetString ( GetRringMinimumW ( bak ) ) ) {
	    ring.minimum = (float) ( atof ( text ) );
	    XtFree ( text );
	}

	if ( text = XmTextGetString ( GetRringIncrementW ( bak ) ) ) {
	    ring.increment = (float) ( atof ( text ) );
	    XtFree ( text );
	}

	if ( text = XmTextGetString ( GetRringStidW ( bak ) ) ) {
	    strcpy ( ring.stid, text );
	    XtFree ( text );
	}

	strcpy ( ring.units, GetRringUnits ( bak ) );

/*
 *	Use the next color
 */
	gd = GetGlobalDataObject();
	GetNextObjectColor ( gd );
	sscanf ( gd->colors, "%d", &color );

/*
 *	Draw radar rings for all stations.
 */
	if ( XmToggleButtonGetState ( GetRringAllstidToggleW ( bak ) ) )
	    strcpy ( ring.stid, "ALL" );
	    
/*
 *	Create object for radar ring(s).
 */
	mlist[0] = (MetObjectType *)
	    MakeRadarRingObject ( index, ring.number, ring.increment,
	                          ring.minimum, ring.units, ring.stid,
	                          color, &iret );

	CopyObjectListToDisplay ( wo, 1, mlist );

	if( wo )
	    ProcessDisplayList( wo );

}
Example #5
0
static void CreateSpinBoxes(Widget parent)
{
    Widget titleLabel, spinBox;
    XmString *valueXmstrings;
    int numValueStrings;
    XmString labelString;
    Arg args[20];
    int i, n;
    
    /* Create value compound strings */

    numValueStrings = XtNumber(spinValueStrings);
    valueXmstrings = (XmString *)XtMalloc(numValueStrings * sizeof(XmString*));
    for (i = 0; i < numValueStrings; i++) {
	valueXmstrings[i] = XmStringCreateLocalized(spinValueStrings[i]);
    }

    /* Create title label */

    labelString = XmStringCreateLocalized("SpinBox Widget");
    n = 0;
    XtSetArg(args[n], XmNlabelString, labelString); n++;
    titleLabel = XmCreateLabel(parent, "title", args, n);
    XtManageChild(titleLabel);
    XmStringFree(labelString);


    /*
     * Create a SimpleSpinBox containing string values.
     */

    n = 0;
    XtSetArg(args[n], XmNvalues, valueXmstrings); n++;
    XtSetArg(args[n], XmNnumValues, numValueStrings); n++;
    XtSetArg(args[n], XmNcolumns, 10); n++;
    spinBox = XmCreateSimpleSpinBox(parent, "spinBox1", args, n);
    XtManageChild(spinBox);


    /*
     * Create a SpinBox containing numeric values to 3 decimal places.
     * Position the arrows on either side of the displayed value.
     */

    n = 0; 
    XtSetArg(args[n], XmNspinBoxChildType, XmNUMERIC); n++;
    XtSetArg(args[n], XmNminimumValue, 1000); n++;
    XtSetArg(args[n], XmNmaximumValue, 100000); n++;
    XtSetArg(args[n], XmNincrementValue,1000); n++;
    XtSetArg(args[n], XmNdecimalPoints,3); n++;
    XtSetArg(args[n], XmNposition,1000); n++;
    XtSetArg(args[n], XmNarrowLayout, XmARROWS_SPLIT); n++;
    XtSetArg(args[n], XmNcolumns, 10); n++;
    spinBox = XmCreateSimpleSpinBox(parent, "spinBox2", args, n);
    XtManageChild(spinBox);


    /*
     * Create a SpinBox containing numeric values to 2 decimal places.
     * Position the arrows on the left of the displayed value.
     * Disallow alternate user changes by adding a modify/verify callback.
     */

    n = 0; 
    XtSetArg(args[n], XmNspinBoxChildType, XmNUMERIC); n++;
    XtSetArg(args[n], XmNminimumValue, 1500); n++;
    XtSetArg(args[n], XmNmaximumValue, 60500); n++;
    XtSetArg(args[n], XmNincrementValue,1500); n++;
    XtSetArg(args[n], XmNdecimalPoints,2); n++;
    XtSetArg(args[n], XmNposition,7500); n++;
    XtSetArg(args[n], XmNarrowLayout, XmARROWS_FLAT_BEGINNING); n++;
    XtSetArg(args[n], XmNcolumns, 10); n++;
    spinBox = XmCreateSimpleSpinBox(parent, "spinBox3", args, n);
    XtManageChild(spinBox);

    XtAddCallback(spinBox, XmNmodifyVerifyCallback, ModifyVerifyCb, NULL);


    /*
     * Create a SpinBox containing string values.
     * Position the arrows on the left of the display value
     */

    n = 0; 
    XtSetArg(args[n], XmNvalues, valueXmstrings); n++;
    XtSetArg(args[n], XmNnumValues, numValueStrings); n++;
    XtSetArg(args[n], XmNarrowLayout, XmARROWS_BEGINNING); n++;
    XtSetArg(args[n], XmNcolumns, 10); n++;
    spinBox = XmCreateSimpleSpinBox(parent, "spinBox4", args, n);
    XtManageChild(spinBox);


    /*
     * Create a SpinBox containing numeric values to 3 decimal places.
     * Position the arrows on the right of the displayed value.
     */

    n = 0;
    XtSetArg(args[n], XmNspinBoxChildType, XmNUMERIC); n++;
    XtSetArg(args[n], XmNminimumValue, 1000); n++;
    XtSetArg(args[n], XmNmaximumValue, 100000); n++;
    XtSetArg(args[n], XmNincrementValue,1000); n++;
    XtSetArg(args[n], XmNdecimalPoints,3); n++;
    XtSetArg(args[n], XmNposition,1000); n++;
    XtSetArg(args[n], XmNarrowLayout, XmARROWS_FLAT_END); n++;
    XtSetArg(args[n], XmNcolumns, 10); n++;
    spinBox = XmCreateSimpleSpinBox(parent, "spinBox5", args, n);
    XtManageChild(spinBox);


    /*
     * Free value strings, SpinBox has taken a copy.
     */

    for (i = 0; i < numValueStrings; i++) {
	XmStringFree(valueXmstrings[i]);
    }
    XtFree((char*)valueXmstrings);

}
Example #6
0
void CoWowMotif::DisplayLicense()
{
    char text[20000];
    Arg	    arg[11];
    Widget  question_widget;
    XmString CStr2, TitleStr, cancelstr;
    XmFontList fontlist;
    XFontStruct *font;
    XmFontListEntry fontentry;
    char title[80];
    Widget w;
    FILE *fp;
    char fname[200];
    int i;
    Widget wcancel;

    strcpy( title, lng_translate("License"));

    sprintf( fname, "$pwr_exe/%s/license.txt", lng_get_language_str());
    dcli_translate_filename( fname, fname);

    fp = fopen( fname, "r");
    if ( !fp) {
      strcpy( fname, "$pwr_exe/en_us/lincense.txt");
      dcli_translate_filename( fname, fname);
      fp = fopen( fname, "r");
      if ( !fp)
	return;
    }

    for ( i = 0; i < (int)sizeof(text) - 1; i++) {
      text[i] = fgetc( fp);
      if ( text[i] == EOF)
	break;
    }
    fclose( fp);
    text[i] = 0;

    // Set default fontlist
    font = XLoadQueryFont( XtDisplay(m_parent),
	      "-*-Helvetica-Bold-R-Normal--12-*-*-*-P-*-ISO8859-1");
    fontentry = XmFontListEntryCreate( (char*) "tag1", XmFONT_IS_FONT, font);
    fontlist = XmFontListAppendEntry( NULL, fontentry);
    XtFree( (char *)fontentry);

    CStr2 = XmStringCreateLtoR( (char*) "", XmSTRING_DEFAULT_CHARSET);
    TitleStr = XmStringCreateLtoR( title, XmSTRING_DEFAULT_CHARSET);    
    cancelstr = XmStringCreateLtoR( (char*) " Close ", XmSTRING_DEFAULT_CHARSET );    
    XtSetArg(arg[0],XmNheight,400);
    XtSetArg(arg[1],XmNwidth,600);
    XtSetArg(arg[2],XmNmessageString, CStr2);
    XtSetArg(arg[3],XmNx,400);
    XtSetArg(arg[4],XmNy,300);
    XtSetArg(arg[5],XmNdialogTitle,TitleStr);
    XtSetArg(arg[6], XmNcancelLabelString, cancelstr);
    XtSetArg(arg[7], XmNbuttonFontList, fontlist);
    XtSetArg(arg[8], XmNlabelFontList, fontlist);

    question_widget = XmCreateMessageDialog( m_parent,(char*) "questionDialog",arg,9);
    XmStringFree( CStr2);
    XmStringFree( TitleStr);
    XmStringFree( cancelstr);
    XmFontListFree( fontlist);
    wcancel = XmMessageBoxGetChild(question_widget, XmDIALOG_CANCEL_BUTTON);
   

    XtSetArg(arg[0], XmNscrollHorizontal, True);
    XtSetArg(arg[1], XmNscrollVertical, True);
    XtSetArg(arg[2], XmNeditMode, XmMULTI_LINE_EDIT);
    XtSetArg(arg[3], XmNeditable, False);
    XtSetArg(arg[4], XmNcursorPositionVisible, False);
    XtSetArg(arg[5], XmNrows, 30);
    XtSetArg(arg[6], XmNvalue, text);
    XtSetArg(arg[7], XmNfontList, fontlist);
    w = XmCreateScrolledText( question_widget, (char*) "text", arg, 7);
    XtVaSetValues( XtParent(w), 
		   XmNleftAttachment, XmATTACH_FORM,
		   XmNrightAttachment, XmATTACH_FORM,
		   XmNtopAttachment, XmATTACH_FORM,
		   XmNbottomAttachment, XmATTACH_WIDGET,
		   XmNbottomWidget, wcancel,
		   NULL);
    XtManageChild(w);

    w = XmMessageBoxGetChild(question_widget, XmDIALOG_OK_BUTTON);
    XtUnmanageChild( w);    
    
    w = XmMessageBoxGetChild(question_widget, XmDIALOG_HELP_BUTTON);
    XtUnmanageChild( w);    

    XtManageChild( question_widget);	       
}
Example #7
0
/************************************************************************
 * PrintOutputSetPageMargins
 *	Set the contents of all the page margins
 ************************************************************************/
void
PrintOutputSetPageMargins(
			PrintOutput *pOutput,
			const char *top,
			const char *right,
			const char *bottom,
			const char *left,
			Boolean *parseError
			)
{
    int		pixels = 0;
    XtEnum	xtParseError = FALSE;
    char	*margin;

    *parseError = FALSE;

    margin = XtNewString(top);
    pixels = XmConvertStringToUnits(
				XtScreenOfObject(pOutput->pShell),
				margin,
				XmVERTICAL,
				XmPIXELS,
				&xtParseError);
    XtFree(margin);
    if (!xtParseError && pixels > 0)
    {
        pOutput->marginTop = pixels;
    }
    else
    {    
	*parseError = TRUE;
        return;
    }

    margin = XtNewString(right);
    pixels = XmConvertStringToUnits(
				XtScreenOfObject(pOutput->pShell),
				margin,
				XmHORIZONTAL,
				XmPIXELS,
				&xtParseError);
    XtFree(margin);
    if (!xtParseError && pixels > 0)
    {
        pOutput->marginRight = pixels;
    }
    else
    {    
	*parseError = TRUE;
        return;
    }

    margin = XtNewString(bottom);
    pixels = XmConvertStringToUnits(
				XtScreenOfObject(pOutput->pShell),
				margin,
				XmVERTICAL,
				XmPIXELS,
				&xtParseError);
    XtFree(margin);
    if (!xtParseError && pixels > 0)
    {
        pOutput->marginBottom = pixels;
    }
    else
    {    
	*parseError = TRUE;
        return;
    }

    margin = XtNewString(left);
    pixels = XmConvertStringToUnits(
				XtScreenOfObject(pOutput->pShell),
				margin,
				XmHORIZONTAL,
				XmPIXELS,
				&xtParseError);
    XtFree(margin);
    if (!xtParseError && pixels > 0)
    {
        pOutput->marginLeft = pixels;
    }
    else
    {    
	*parseError = TRUE;
        return;
    }

    _poSetInnerPageDimensions(
			pOutput,
			pOutput->marginTop,
			pOutput->marginRight,
			pOutput->marginBottom,
			pOutput->marginLeft);
}
Example #8
0
int THD_datablock_from_atr( THD_datablock *dblk, char *dirname, char *headname )
{
   THD_diskptr       *dkptr ;
   ATR_int           *atr_rank , *atr_dimen , *atr_scene , *atr_btype ;
   ATR_float         *atr_flt ;
   ATR_string        *atr_labs ;
   int   ii , view_type , func_type , dset_type , 
         nx,ny,nz,nvox , nvals , ibr,typ ;
   Boolean ok ;
   char prefix[THD_MAX_NAME]="Unknown" ;
   MRI_IMAGE *qim ;
   int brick_ccode ;
   char name[666] ;

ENTRY("THD_datablock_from_atr") ;

   if( dblk == NULL || dblk->natr <= 0 ) RETURN(0) ; /* bad input */

   dkptr = dblk->diskptr ;

   /*-- get relevant attributes: rank, dimensions, view_type & func_type --*/

   atr_rank  = THD_find_int_atr( dblk , ATRNAME_DATASET_RANK ) ;
   atr_dimen = THD_find_int_atr( dblk , ATRNAME_DATASET_DIMENSIONS ) ;
   atr_scene = THD_find_int_atr( dblk , ATRNAME_SCENE_TYPE ) ;

   /*-- missing an attribute ==> quit now --*/

   if( atr_rank == NULL || atr_dimen == NULL || atr_scene == NULL ) RETURN(0) ;

   /*-- load type codes from SCENE attribute --*/

   STATUS("loading *_type from SCENE") ;

   view_type = atr_scene->in[0] ;
   func_type = atr_scene->in[1] ;
   dset_type = atr_scene->in[2] ;

   /*-- load other values from attributes into relevant places --*/

   ok   = True ;
   nvox = 1 ;

   STATUS("loading from RANK") ;

   dkptr->rank = atr_rank->in[0] ;                /* N.B.: rank isn't used much */
   dkptr->nvals = dblk->nvals = nvals = atr_rank->in[1] ;  /* but nvals is used */

   STATUS("loading from DIMENSIONS") ;

   for( ii=0 ; ii < dkptr->rank ; ii++ ){
     dkptr->dimsizes[ii] = atr_dimen->in[ii] ;
     ok                  = ( ok && dkptr->dimsizes[ii] >= 1 ) ;
     nvox               *= dkptr->dimsizes[ii] ;
   }

#if 0
   if( PRINT_TRACING ){
     char str[256] ;
     sprintf(str,"rank=%d nvals=%d dim[0]=%d dim[1]=%d dim[2]=%d nvox=%d",
             dkptr->rank , dkptr->nvals ,
             dkptr->dimsizes[0] , dkptr->dimsizes[1] , dkptr->dimsizes[2] , nvox ) ;
     STATUS(str) ;
   }
#endif

   if( !ok || nvals < 1 ||
       dkptr->rank < THD_MIN_RANK || dkptr->rank > THD_MAX_RANK ){
     STATUS("bad rank!!??") ;
     RETURN(0) ;
   }

   /*-- create the storage filenames --*/

   STATUS("creating storage filenames") ;

   if( headname != NULL && strchr(headname,'+') != NULL ){
     FILENAME_TO_PREFIX(headname,prefix) ;
     THD_init_diskptr_names( dkptr, dirname,NULL,prefix , view_type , True ) ;
   } else {
     if( headname != NULL ) MCW_strncpy(prefix,headname,THD_MAX_NAME) ;
     THD_init_diskptr_names( dkptr, dirname,NULL,prefix , view_type , True ) ;
   }

   /*-- determine if the BRIK file exists --*/

   STATUS("checking if .BRIK file exists") ;

   brick_ccode = COMPRESS_filecode(dkptr->brick_name) ;
   if (dkptr->storage_mode == STORAGE_UNDEFINED) { /* ZSS: Oct. 2011 
               the next line was being called all the time before */
      if( brick_ccode != COMPRESS_NOFILE )
        dkptr->storage_mode = STORAGE_BY_BRICK ;  /* a .BRIK file */
   }
   
   /*-- if VOLUME_FILENAMES attribute exists, make it so [20 Jun 2002] --*/

   if( headname != NULL && dkptr->storage_mode == STORAGE_UNDEFINED ){
     atr_labs = THD_find_string_atr(dblk,"VOLUME_FILENAMES") ;
     if( atr_labs != NULL ){
       dkptr->storage_mode = STORAGE_BY_VOLUMES ;
       dblk->malloc_type   = DATABLOCK_MEM_MALLOC ;
     }
   }

   /*-- now set the memory allocation codes, etc. --*/

   dblk->brick_fac = (float *) XtMalloc( sizeof(float) * nvals ) ;
   for( ibr=0 ; ibr < nvals ; ibr++ ) dblk->brick_fac[ibr] = 0.0 ;

   /* scaling factors from short type to float type, if nonzero */

   if( !AFNI_yesenv("AFNI_IGNORE_BRICK_FLTFAC") ){
     atr_flt = THD_find_float_atr( dblk , ATRNAME_BRICK_FLTFAC ) ;
     if( atr_flt != NULL ){
       for( ibr=0 ; ibr < nvals && ibr < atr_flt->nfl ; ibr++ )
         dblk->brick_fac[ibr] = atr_flt->fl[ibr] ;
     }
   }

   /** Now create an empty shell of the "brick" == the data structure
       that will hold all the voxel data.  Note that all datablocks
       will have a brick, even if they never actually contain data
       themselves (are only warp-on-demand).

       If the BRICK_TYPES input attribute doesn't exist, then all
       sub-bricks are shorts.  This makes the code work with old-style
       datasets, which were always made up of shorts.
   **/

   atr_btype = THD_find_int_atr( dblk , ATRNAME_BRICK_TYPES ) ;

   if( atr_btype == NULL ){
     THD_init_datablock_brick( dblk , MRI_short , NULL ) ;
   } else {
     THD_init_datablock_brick( dblk , atr_btype->nin , atr_btype->in ) ;
   }

   if( !THD_datum_constant(dblk) ){ /* 15 Sep 2004 */
     fprintf(stderr,
             "\n** WARNING: File %s has mixed-type sub-bricks. ", MYHEAD ) ;
   }

   /* 25 April 1998: check if the byte order is stored inside */

   atr_labs = THD_find_string_atr( dblk , ATRNAME_BYTEORDER ) ;
   if( atr_labs != NULL && atr_labs->nch > 0 ){

     if( strncmp(atr_labs->ch,LSB_FIRST_STRING,ORDER_LEN) == 0 )
       dkptr->byte_order = LSB_FIRST ;
     else if( strncmp(atr_labs->ch,MSB_FIRST_STRING,ORDER_LEN) == 0 )
       dkptr->byte_order = MSB_FIRST ;
     else
       fprintf(stderr,"*** Unknown %s found in dataset %s\n",
               ATRNAME_BYTEORDER , MYHEAD ) ;

   } else if( !no_ordwarn                         &&
              DBLK_BRICK_TYPE(dblk,0) != MRI_byte &&
              dblk->diskptr->storage_mode == STORAGE_BY_BRICK ){ /* 20 Sep 1999 */

     static int first=1 ;
     if( first ){
       fprintf(stderr,
         "\n*** The situation below can be rectified with program '3drefit -byteorder':\n");
       first = 0 ;
     }
     fprintf(stderr," ** Dataset %s: assuming byteorder %s\n",
             MYHEAD , BYTE_ORDER_STRING(dkptr->byte_order)  ) ;
   }

   /* if the data is not on disk, the flag remains at DATABLOCK_MEM_UNDEFINED,
      otherwise the flag says how the memory for the bricks is to be created. */

   if( dkptr->storage_mode == STORAGE_BY_BRICK ){
#if MMAP_THRESHOLD > 0
     dblk->malloc_type = (dblk->total_bytes > MMAP_THRESHOLD)
                         ? DATABLOCK_MEM_MMAP : DATABLOCK_MEM_MALLOC ;
     DBLK_mmapfix(dblk) ;  /* 18 Mar 2005 */
#else
     dblk->malloc_type = DATABLOCK_MEM_MALLOC ;
#endif

     /* must be malloc-ed if:
           data is compressed,
           data is not in native byte order, or
           user explicity forbids use of mmap   */

     if( brick_ccode >= 0 || dkptr->byte_order != native_order || no_mmap )
        dblk->malloc_type = DATABLOCK_MEM_MALLOC ;
   }

   /* 30 Nov 1997: create the labels for sub-bricks */

   THD_init_datablock_labels( dblk ) ;

   atr_labs = THD_find_string_atr( dblk , ATRNAME_BRICK_LABS ) ;
   if( atr_labs != NULL && atr_labs->nch > 0 ){  /* create labels from attribute */
     int ipos = -1 , ipold , ngood ;

     for( ibr=0 ; ibr < nvals ; ibr++ ){  /* loop over bricks */

       for( ipold = ipos++ ;                                     /* skip to */
            ipos < atr_labs->nch && atr_labs->ch[ipos] != '\0' ; /* next \0 */
            ipos++ ) /* nada */ ;                                /* or end. */

       ngood = ipos - ipold - 1 ;                   /* number of good chars */
       if( ngood > 0 ){
         XtFree(dblk->brick_lab[ibr]) ;
         /* 27 Oct 2011 - increase to 64 */
         if( ngood > THD_MAX_SBLABEL ) ngood = THD_MAX_SBLABEL;  
         dblk->brick_lab[ibr] = (char *) XtMalloc(sizeof(char)*(ngood+2)) ;
         memcpy( dblk->brick_lab[ibr] , atr_labs->ch+(ipold+1) , ngood ) ;
         dblk->brick_lab[ibr][ngood] = '\0' ;

       }

        if( ipos >= atr_labs->nch ) break ;  /* nothing more to do */
     } /* end of loop over sub-bricks */
   }

   /* create the keywords for sub-bricks */

   THD_init_datablock_keywords( dblk ) ;

   atr_labs = THD_find_string_atr( dblk , ATRNAME_BRICK_KEYWORDS ) ;

   if( atr_labs != NULL && atr_labs->nch > 0 ){  /* create keywords from attribute */
     int ipos = -1 , ipold , ngood ;

     for( ibr=0 ; ibr < nvals ; ibr++ ){  /* loop over bricks */

       for( ipold = ipos++ ;                                     /* skip to */
            ipos < atr_labs->nch && atr_labs->ch[ipos] != '\0' ; /* next \0 */
            ipos++ ) /* nada */ ;                                /* or end. */

       ngood = ipos - ipold - 1 ;                   /* number of good chars */
       if( ngood > 0 ){
         XtFree(dblk->brick_keywords[ibr]) ;
         dblk->brick_keywords[ibr] = (char *) XtMalloc(sizeof(char)*(ngood+2)) ;
         memcpy( dblk->brick_keywords[ibr] , atr_labs->ch+(ipold+1) , ngood ) ;
         dblk->brick_keywords[ibr][ngood] = '\0' ;
       }

       if( ipos >= atr_labs->nch ) break ;  /* nothing more to do */
     } /* end of loop over sub-bricks */
   }

   /* create the auxiliary statistics stuff for each brick, if present */

   atr_labs = THD_find_string_atr( dblk , "BRICK_STATSYM" ) ;  /* 01 Jun 2005 */
   if( atr_labs != NULL && atr_labs->nch > 0 ){
     NI_str_array *sar ; int scode,np ; float parm[3] ;
     sar = NI_decode_string_list( atr_labs->ch , ";" ) ;
     if( sar != NULL && sar->num > 0 ){
       for( ibr=0 ; ibr < nvals && ibr < sar->num ; ibr++ ){
         NI_stat_decode( sar->str[ibr] , &scode , parm,parm+1,parm+2 ) ;
         if( scode >= AFNI_FIRST_STATCODE && scode <= AFNI_LAST_STATCODE ){
           np = NI_stat_numparam(scode) ;
           THD_store_datablock_stataux( dblk , ibr,scode,np,parm ) ;
         }
       }
       NI_delete_str_array(sar) ;
     }
   } else {          /*--- the olde way to get ye brick stataux parameters ---*/
     atr_flt = THD_find_float_atr( dblk , ATRNAME_BRICK_STATAUX ) ;
     if( atr_flt != NULL && atr_flt->nfl >= 3 ){
       int ipos=0 , iv,nv,jv ;

       /* attribute stores all stataux stuff as follows:
            sub-brick-index  statcode  no.-of-values value ... value
            sub-brick-index  statcode  no.-of-values value ... value, etc. */

       while( ipos <= atr_flt->nfl - 3 ){
         iv = (int) ( atr_flt->fl[ipos++] ) ;  /* which sub-brick */
         jv = (int) ( atr_flt->fl[ipos++] ) ;  /* statcode */
         nv = (int) ( atr_flt->fl[ipos++] ) ;  /* # of values that follow */

         if( nv > atr_flt->nfl - ipos ) nv = atr_flt->nfl - ipos ;

         THD_store_datablock_stataux( dblk , iv , jv , nv , atr_flt->fl + ipos ) ;
         ipos += nv ;
       }
     }
   }
#if 0
   if( PRINT_TRACING ){
     char str[256] ;
     sprintf(str,"rank=%d nvals=%d dim[0]=%d dim[1]=%d dim[2]=%d",
             dkptr->rank , dkptr->nvals ,
             dkptr->dimsizes[0] , dkptr->dimsizes[1] , dkptr->dimsizes[2] ) ;
     STATUS(str) ;
   }
#endif

   /*-- FDR curves [23 Jan 2008] --*/

   for( ibr=0 ; ibr < dblk->nvals ; ibr++ ){
     sprintf(name,"FDRCURVE_%06d",ibr) ;
     atr_flt = THD_find_float_atr( dblk , name ) ;
     if( atr_flt != NULL && atr_flt->nfl > 3 ){
       int nv = atr_flt->nfl - 2 ; floatvec *fv ;
       MAKE_floatvec(fv,nv) ;
       fv->x0 = atr_flt->fl[0] ; fv->dx = atr_flt->fl[1] ;
       memcpy( fv->ar , atr_flt->fl + 2 , sizeof(float)*nv ) ;
       if( dblk->brick_fdrcurve == NULL )
         dblk->brick_fdrcurve = (floatvec **)calloc(sizeof(floatvec *),dblk->nvals);
       dblk->brick_fdrcurve[ibr] = fv ;
     }
   }

   for( ibr=0 ; ibr < dblk->nvals ; ibr++ ){
     sprintf(name,"MDFCURVE_%06d",ibr) ;
     atr_flt = THD_find_float_atr( dblk , name ) ;
     if( atr_flt != NULL && atr_flt->nfl > 3 ){
       int nv = atr_flt->nfl - 2 ; floatvec *fv ;
       MAKE_floatvec(fv,nv) ;
       fv->x0 = atr_flt->fl[0] ; fv->dx = atr_flt->fl[1] ;
       memcpy( fv->ar , atr_flt->fl + 2 , sizeof(float)*nv ) ;
       if( dblk->brick_mdfcurve == NULL )
         dblk->brick_mdfcurve = (floatvec **)calloc(sizeof(floatvec *),dblk->nvals);
       dblk->brick_mdfcurve[ibr] = fv ;
     }
   }

   RETURN(1) ;
}
Example #9
0
void THD_datablock_apply_atr( THD_3dim_dataset *dset )
{
   THD_datablock     *blk ;
   THD_diskptr       *dkptr ;
   THD_dataxes       *daxes ;
   ATR_int           *atr_int = NULL ;
   ATR_float         *atr_flt = NULL;
   ATR_string        *atr_str = NULL ;
   int ii , view_type , func_type , dset_type , nx,ny,nz,nvox , nvals , ibr,typ ;
   Boolean ok ;
   char prefix[THD_MAX_NAME]="Unknown" ;
   MRI_IMAGE *qim ;
   int brick_ccode ;
   char name[666] ;

ENTRY("THD_datablock_apply_atr") ;

   if( !ISVALID_DSET(dset) ) EXRETURN ; /* bad input */

   blk   = dset->dblk   ;  if( blk == NULL   ) EXRETURN ;
   nvals = blk->nvals   ;  if( nvals <= 0    ) EXRETURN ;
   daxes = dset->daxes  ;  if( daxes == NULL ) EXRETURN ;
   dkptr = blk->diskptr ;

   /*-- brick labels --*/

   if( ATR_IS_STR(ATRNAME_BRICK_LABS) ){
     int ipos = -1 , ipold , ngood ;

     STATUS("brick labels") ;
     if( blk->brick_lab == NULL ) THD_init_datablock_labels( blk ) ;

     for( ibr=0 ; ibr < nvals ; ibr++ ){  /* loop over bricks */

       for( ipold = ipos++ ;                                   /* skip to */
            ipos < atr_str->nch && atr_str->ch[ipos] != '\0' ; /* next \0 */
            ipos++ ) /* nada */ ;                              /* or end. */

       ngood = ipos - ipold - 1 ;                 /* number of good chars */
       if( ngood > 0 ){
         XtFree(blk->brick_lab[ibr]) ;
         if( ngood > THD_MAX_SBLABEL ) ngood = THD_MAX_SBLABEL ;
         blk->brick_lab[ibr] = (char *) XtMalloc(sizeof(char)*(ngood+2)) ;
         memcpy( blk->brick_lab[ibr] , atr_str->ch+(ipold+1) , ngood ) ;
         blk->brick_lab[ibr][ngood] = '\0' ;
       }

        if( ipos >= atr_str->nch ) break ;  /* nothing more to do */
     } /* end of loop over sub-bricks */
   }

   /*-- keywords for the dataset itself --*/

   if( ATR_IS_STR(ATRNAME_KEYWORDS) ){
     STATUS("dataset keywords") ;
     dset->keywords = XtNewString( atr_str->ch ) ;
   }

   /*-- keywords for sub-bricks --*/

   if( ATR_IS_STR(ATRNAME_BRICK_KEYWORDS) ){
     int ipos = -1 , ipold , ngood ;

     STATUS("brick keywords") ;
     if( blk->brick_keywords == NULL ) THD_init_datablock_keywords( blk ) ;

     for( ibr=0 ; ibr < nvals ; ibr++ ){  /* loop over bricks */

       for( ipold = ipos++ ;                                   /* skip to */
            ipos < atr_str->nch && atr_str->ch[ipos] != '\0' ; /* next \0 */
            ipos++ ) /* nada */ ;                              /* or end. */

       ngood = ipos - ipold - 1 ;                 /* number of good chars */
       if( ngood > 0 ){
         XtFree(blk->brick_keywords[ibr]) ;
         blk->brick_keywords[ibr] = (char *) XtMalloc(sizeof(char)*(ngood+2)) ;
         memcpy( blk->brick_keywords[ibr] , atr_str->ch+(ipold+1) , ngood ) ;
         blk->brick_keywords[ibr][ngood] = '\0' ;
       }

       if( ipos >= atr_str->nch ) break ;  /* nothing more to do */
     } /* end of loop over sub-bricks */
   }

   /*-- auxiliary statistics stuff for each brick --*/

   if( ATR_IS_FLT(ATRNAME_BRICK_STATAUX) ){
     int ipos=0 , iv,nv,jv ;

     STATUS("brick stataux") ;

     /* attribute stores all stataux stuff as follows:
          sub-brick-index  statcode  no.-of-values value ... value
          sub-brick-index  statcode  no.-of-values value ... value, etc. */

     while( ipos <= atr_flt->nfl - 3 ){
       iv = (int) ( atr_flt->fl[ipos++] ) ;  /* which sub-brick */
       jv = (int) ( atr_flt->fl[ipos++] ) ;  /* statcode */
       nv = (int) ( atr_flt->fl[ipos++] ) ;  /* # of values that follow */

       if( nv > atr_flt->nfl - ipos ) nv = atr_flt->nfl - ipos ;

       THD_store_datablock_stataux( blk , iv , jv , nv , atr_flt->fl + ipos ) ;
       ipos += nv ;
     }
   }

   /*-- FDR curves [23 Jan 2008] --*/

   for( ibr=0 ; ibr < blk->nvals ; ibr++ ){
     sprintf(name,"FDRCURVE_%06d",ibr) ;
     atr_flt = THD_find_float_atr( blk , name ) ;
     if( atr_flt != NULL && atr_flt->nfl > 3 ){
       int nv = atr_flt->nfl - 2 ; floatvec *fv ;
       MAKE_floatvec(fv,nv) ;
       fv->x0 = atr_flt->fl[0] ; fv->dx = atr_flt->fl[1] ;
       memcpy( fv->ar , atr_flt->fl + 2 , sizeof(float)*nv ) ;
       if( blk->brick_fdrcurve == NULL )
         blk->brick_fdrcurve = (floatvec **)calloc(sizeof(floatvec *),blk->nvals);
       blk->brick_fdrcurve[ibr] = fv ;
     }
   }

   for( ibr=0 ; ibr < blk->nvals ; ibr++ ){
     sprintf(name,"MDFCURVE_%06d",ibr) ;
     atr_flt = THD_find_float_atr( blk , name ) ;
     if( atr_flt != NULL && atr_flt->nfl > 3 ){
       int nv = atr_flt->nfl - 2 ; floatvec *fv ;
       MAKE_floatvec(fv,nv) ;
       fv->x0 = atr_flt->fl[0] ; fv->dx = atr_flt->fl[1] ;
       memcpy( fv->ar , atr_flt->fl + 2 , sizeof(float)*nv ) ;
       if( blk->brick_mdfcurve == NULL )
         blk->brick_mdfcurve = (floatvec **)calloc(sizeof(floatvec *),blk->nvals);
       blk->brick_mdfcurve[ibr] = fv ;
     }
   }

   /*-- ID codes --*/

   if( ATR_IS_STR(ATRNAME_IDSTRING) )
     MCW_strncpy( dset->idcode.str , atr_str->ch , MCW_IDSIZE ) ;

   if( ATR_IS_STR(ATRNAME_IDDATE) )
     MCW_strncpy( dset->idcode.date , atr_str->ch , MCW_IDDATE ) ;

   if( ATR_IS_STR(ATRNAME_IDANATPAR) )
     MCW_strncpy( dset->anat_parent_idcode.str , atr_str->ch , MCW_IDSIZE ) ;

   if( ATR_IS_STR(ATRNAME_IDWARPPAR) )
     MCW_strncpy( dset->warp_parent_idcode.str , atr_str->ch , MCW_IDSIZE ) ;

   /*-- parent names --*/

   if( ATR_IS_STR(ATRNAME_ANATOMY_PARENT) &&
       ISZERO_IDCODE(dset->anat_parent_idcode) )
     MCW_strncpy( dset->anat_parent_name , atr_str->ch , THD_MAX_NAME ) ;

   if( ATR_IS_STR(ATRNAME_WARP_PARENT) &&
       ISZERO_IDCODE(dset->warp_parent_idcode) )
     MCW_strncpy( dset->warp_parent_name , atr_str->ch , THD_MAX_NAME ) ;

   if( ATR_IS_STR(ATRNAME_DATANAME) )
     MCW_strncpy( dset->self_name , atr_str->ch , THD_MAX_NAME ) ;

   /*-- markers --*/

   if( ATR_IS_FLT(ATRNAME_MARKSXYZ) && ATR_IS_STR(ATRNAME_MARKSLAB) ){
     int im , llen ;
     THD_ivec3 iv ;
     float xxdown,xxup , yydown,yyup , zzdown,zzup ;

     STATUS("markers") ;

     if( dset->markers == NULL ){
       dset->markers = myXtNew( THD_marker_set ) ;  /* new set */
       ADDTO_KILL(dset->kl , dset->markers) ;
     }

     COPY_INTO_STRUCT( *(dset->markers) ,  /* actual struct */
                       MARKS_FSTART ,      /* byte offset */
                       float ,             /* type being copied */
                       atr_flt->fl ,       /* start of source */
                       MARKS_FSIZE  ) ;    /* number of floats */

     COPY_INTO_STRUCT( *(dset->markers) ,
                       MARKS_LSTART ,
                       char ,
                       atr_str->ch ,
                       MARKS_LSIZE  ) ;

     xxdown = daxes->xxmin ; xxup = daxes->xxmax ;
     yydown = daxes->yymin ; yyup = daxes->yymax ;
     zzdown = daxes->zzmin ; zzup = daxes->zzmax ;

     dset->markers->numdef = dset->markers->numset = 0 ;

     for( im=0 ; im < MARKS_MAXNUM ; im++ ){
       llen = strlen( &(dset->markers->label[im][0]) ) ;
       dset->markers->valid[im]   =
          (llen > 0) &&
          ( dset->markers->xyz[im][0] >= xxdown ) &&
          ( dset->markers->xyz[im][0] <= xxup   ) &&
          ( dset->markers->xyz[im][1] >= yydown ) &&
          ( dset->markers->xyz[im][1] <= yyup   ) &&
          ( dset->markers->xyz[im][2] >= zzdown ) &&
          ( dset->markers->xyz[im][2] <= zzup   )    ;

       if( dset->markers->valid[im] ) (dset->markers->numset)++ ;

       if( llen > 0 ) (dset->markers->numdef)++ ;

       dset->markers->ovcolor[im] = -1 ;  /* default color */
     }

     if( ATR_IS_STR(ATRNAME_MARKSHELP) ){
       COPY_INTO_STRUCT( *(dset->markers) ,
                          MARKS_HSTART ,
                          char ,
                          atr_str->ch ,
                          MARKS_HSIZE  ) ;
     } else {
       for( im=0 ; im < MARKS_MAXNUM ; im++ )   /* no help */
Example #10
0
void 
make_scatmat(xgobidata *xg)
{
  int i, i2, j, k, *cols, ncells;
  float *min, *max, **scatmat, cpi5, spi5;
  double pi5;

  ncells = xg->nrows*xg->ncols_used*(xg->ncols_used-1)/2;
  min = (float *) XtMalloc((Cardinal) xg->ncols * sizeof(float));
  max = (float *) XtMalloc((Cardinal) xg->ncols * sizeof(float));
  cols = (int *) XtMalloc((Cardinal) xg->ncols * sizeof(int));
  scatmat = (float **) XtMalloc((Cardinal) ncells * sizeof(float *));
  for (i=0; i<ncells; i++)
    scatmat[i] = (float *) XtMalloc((Cardinal) 4 * sizeof(float));

  for (j=0; j<xg->ncols_used; j++)
  {
    min[j]=xg->raw_data[0][j];
    max[j]=xg->raw_data[0][j];
    for (i=0; i<xg->nrows; i++)
    {
      if (min[j] > xg->raw_data[i][j])
        min[j] = xg->raw_data[i][j];
      if (max[j] < xg->raw_data[i][j])
        max[j] = xg->raw_data[i][j];
    }
  }

  for (j=0; j<xg->ncols_used; j++)
    for (i=0; i<xg->nrows; i++)
    {
      if (max[j]-min[j] > 0)
        xg->raw_data[i][j] = (xg->raw_data[i][j]-min[j])/(max[j]-min[j]);
      else
        xg->raw_data[i][j] = 0.5;
    }

  /* Horizontal layout variable */
  k=0;
  for (j=2; j<=xg->ncols_used; j++)
  {
    for (i=0; i<xg->nrows*(xg->ncols_used-j+1); i++)
    {
      scatmat[k][0] = j-1;
      k++;
    }
  }

  /* Vertical layout variable */
  k=0;
  for (j=2; j<=xg->ncols_used; j++)
  {
    for (i=xg->ncols_used-j+1; i>0; i--)
      for (i2=0; i2<xg->nrows; i2++)
      {
        scatmat[k][1] = i;
        k++;
      }
  }

  /* Horizontal variable values */
  k=0;
  for (j=2; j<=xg->ncols_used; j++)
  {
    for (i=0; i<(xg->ncols_used-j+1); i++)
      for (i2=0; i2<xg->nrows; i2++)
      {
        scatmat[k][2] = xg->raw_data[i2][j-2];
        k++;
      }
  }

  /* Vertical variable values */
  k=0;
  for (j=2; j<=xg->ncols_used; j++)
  {
    for (i=j; i<=xg->ncols_used; i++)
      for (i2=0; i2<xg->nrows; i2++)
      {
        scatmat[k][3] = xg->raw_data[i2][i-1];
        k++;
      }
  }

  for (i=0; i<xg->nrows; i++)
      XtFree((XtPointer) xg->raw_data[i]);
  XtFree((char *) xg->raw_data);

  xg->sm_nrows = xg->nrows;
  xg->sm_ncols = xg->ncols_used;
  xg->nrows = ncells+xg->sm_ncols;/* additional piece to do var labels */
  xg->ncols = 3;
  xg->ncols_used = 2;
  xg->raw_data = (float **) XtMalloc((Cardinal) xg->nrows * sizeof(float *));
  for (i=0; i<xg->nrows ; i++)
    xg->raw_data[i] = (float *) XtMalloc((Cardinal) xg->ncols * sizeof(float));

  pi5 = (double) M_PI/5.;
  cpi5 = (float) cos(pi5);
  spi5 = (float) sin(pi5);
  /*  make dummy points for labels */
  for (i=0; i<xg->nrows-xg->sm_ncols; i++)
  {
    xg->raw_data[i][0] = cpi5*scatmat[i][0]+spi5*scatmat[i][2];
    xg->raw_data[i][1] = cpi5*scatmat[i][1]+spi5*scatmat[i][3];
  }
  for (j=0; j<xg->sm_ncols; j++)
  {
    xg->raw_data[xg->nrows-xg->sm_ncols+j][0] = cpi5*(j+1)+spi5*0.5;
    xg->raw_data[xg->nrows-xg->sm_ncols+j][1] = cpi5*(xg->sm_ncols-j)+spi5*0.5;
  }

  for (i=0; i<xg->nrows-xg->sm_ncols; i++)
      XtFree((XtPointer) scatmat[i]);
  XtFree((XtPointer) scatmat);
  XtFree((XtPointer) min);
  XtFree((XtPointer) max);
  XtFree((XtPointer) cols);
}
Example #11
0
int
Sread_array(xgobidata *xg)
{
  int i, j, nitems = 0;
  int ok = 0;
  FILE *fp;
  char word[64];

  if ((fp = fopen((char *) xg->datafname, "r")) == NULL) {
    (void) fprintf(stderr,
      "Sread_array: data file %s does not exist\n", xg->datafname);
    exit(0);

  }

  else
  {
    xg->raw_data = (float **) XtMalloc(
			(Cardinal) xg->nrows * sizeof(float *));
    for (i=0; i<xg->nrows; i++)
      xg->raw_data[i] = (float *) XtMalloc(
				(Cardinal) xg->ncols * sizeof(float));

    /*
     * Allocate space for missing data, and free it if
     * it isn't used.
    */
    xg->is_missing = (short **) XtMalloc(
			(Cardinal) xg->nrows * sizeof(short *));
    for (i=0; i<xg->nrows; i++)
      xg->is_missing[i] = (short *) XtMalloc(
				(Cardinal) xg->ncols * sizeof(short));

    for (i=0; i<xg->nrows; i++) {
      for (j=0; j<xg->ncols_used; j++) {
        (void) fscanf(fp, "%s", word);
        if (strcasecmp(word, "na") == 0 || strcmp(word, ".") == 0) {
          if (!xg->missing_values_present)
            xg->missing_values_present = True;
          xg->is_missing[i][j] = 1;
          xg->raw_data[i][j] = 0.0;
        } else {
          xg->is_missing[i][j] = 0;
          xg->raw_data[i][j] = (float) atof(word);
        }
        nitems++;
      }
    }

    /*
     * Test the number of items read against the dimension
     * of the array.
    */
    if (nitems == xg->nrows * xg->ncols_used)
    {
      ok = 1;
      if (unlink((char *) xg->datafname) != 0)
        fprintf(stderr, "Sread_array: error in unlink\n");
    }
    else
    {
      ok = 0;
      (void) fprintf(stderr, "Sread_array: nrows*ncols != nitems\n");
      exit(0);
    }

    /*
     * Now fill some data into the extra column, which will be
     * used if groups are defined by brushing.
    */
    for (i=0; i<xg->nrows; i++) {
      xg->raw_data[i][xg->ncols_used] = 1.0;
      xg->is_missing[i][xg->ncols_used] = 0;
    }

    /*
     * If we haven't yet encountered a missing value, free up
     * the whole matrix.
    */
    if (!xg->missing_values_present)
    {
      for (i=0; i<xg->nrows; i++)
        XtFree((XtPointer) xg->is_missing[i]);
      XtFree((char *) xg->is_missing);
      xg->is_missing = (short **) NULL;
    }
  }

  return(ok);
}
Example #12
0
void
read_ascii(FILE *fp, xgobidata *xg)
{
  register int ch;
  int i, j, k, jrows, nrows, jcols, fs;
  int nitems;
  float row1[NCOLS];
  short row1_missing[NCOLS];
  int nblocks;
  char word[64];

  /* Initialize these before starting */
  for (k=0; k<NCOLS; k++) {
    row1_missing[k] = 0;
    row1[k] = 0.0;
  }
  xg->ncols_used = 0;

  init_file_rows_sampled(xg);

/*
 * Find the index of the first row of data that we're interested in.
*/

  nrows = 0;
  if (xg->file_read_type == read_all) {
    if (find_data_start(fp) == False)
      return;

  } else {  /* if -only was used on the command line */
    if (!seek_to_file_row(nrows, fp, xg))
      return;
  }

/*
 * Read in the first row of the data file and calculate ncols.
*/

  gotone = True;

/*
 * I've left behind some checking that's done in bak/read_array.c --
 * test xgobi on a text file and see what happens.
*/

  while ( (ch = getc(fp)) != '\n') {

    if (ch == '\t' || ch == ' ')
      ;

    else if ( ungetc(ch, fp) == EOF || fscanf(fp, "%s", word) < 0 ) {
      fprintf(stderr,
        "read_array: error in reading first row of data\n");
      fclose(fp);
      exit(0);

    } else {

      if ( strcasecmp(word, "na") == 0 || strcmp(word, ".") == 0) {
        xg->missing_values_present = True;
        xg->nmissing++;
        row1_missing[xg->ncols_used] = 1;

      } else {
        row1[xg->ncols_used] = (float) atof(word);
      }
      xg->ncols_used++ ;

      if (xg->ncols_used >= NCOLS) {
        fprintf(stderr,
         "This file has more than %d columns.  In order to read it in,\n",
          NCOLS);
        fprintf(stderr,
         "increase NCOLS in xgobitypes.h and recompile.\n");
        exit(0);
      }
    }
  }

  xg->ncols = xg->ncols_used + 1;

/*
 * If we're reading everything, allocate the first block.
 * If -only has been used, allocate the whole shebang.
*/
  if (xg->file_read_type == read_all) {

    xg->nrows = 0;
    alloc_block(1, xg);
    if (xg->missing_values_present)
      alloc_missing_block(1, xg);

  } else {  /* -only has been used */

    xg->nrows = xg->file_sample_size;
    xg->raw_data = (float **) XtMalloc(
      (Cardinal) xg->nrows * sizeof(float *));
    for (i=0; i<xg->nrows; i++)
      xg->raw_data[i] = (float *)
        XtMalloc((Cardinal) xg->ncols * sizeof(float));

    if (xg->missing_values_present)
      init_missing_array(xg->nrows, xg->ncols, xg);
  }

/*
 * Fill in the first row
*/
  for (j=0; j<xg->ncols_used; j++)
    xg->raw_data[0][j] = row1[j];
  if (xg->missing_values_present) {
    for (j=0; j<xg->ncols_used; j++)
      xg->is_missing[0][j] = row1_missing[j];
  }
  nrows++;

/*
 * Read data, reallocating as needed.  Determine nrows for the read_all case.
*/
  nblocks = 1;
  nitems = xg->ncols_used;
  jrows = 1;
  jcols = 0;
  while (1)
  {

    if (jcols == 0) {
      if (xg->file_read_type == read_all) {
        if (!find_data_start(fp))
          break;

      } else {  /* if -only was used on the command line */
        if (!seek_to_file_row(nrows, fp, xg))
          break;
      }
    }

    fs = fscanf(fp, "%s", word);

    if (fs == EOF)
      break;
    else if (fs < 0)
    {
      fprintf(stderr, "Problem with input data\n");
      fclose(fp);
      exit(0);
    }
    else
    {
      nitems++;

      if ( strcasecmp(word, "na") == 0 || strcmp(word, ".") == 0 ) {

        if (!xg->missing_values_present) {
          xg->missing_values_present = True;
          /*
           * Only when the first "na" or "." has been encountered
           * is it necessary to allocate space to contain the
           * missing values matrix.  Initialize all previous values
           * to 0.
          */
          if (xg->file_read_type == read_all) {
            alloc_missing_block(nblocks, xg);
            for (i=BLOCKSIZE*(nblocks-1); i<BLOCKSIZE*nblocks; i++) {
              for (k=0; k<xg->ncols_used; k++)
                xg->is_missing[i][k] = 0;
            }
          } else {
            init_missing_array(xg->nrows, xg->ncols, xg);
          }
        }

        xg->nmissing++;
        xg->is_missing[nrows][jcols] = 1;
        xg->raw_data[nrows][jcols] = 0.0;
      }
      else
        xg->raw_data[nrows][jcols] = (float) atof(word);

      jcols++;
      if (jcols == xg->ncols_used)
      {
        jcols = 0;
        nrows++;
        jrows++;
      }

      if (xg->file_read_type == read_all) {
        if (jrows == BLOCKSIZE) {
          jrows = 0;
          nblocks++;
          if (nblocks%20 == 0)
            fprintf(stderr, "reallocating; n > %d\n", nblocks*BLOCKSIZE);

          alloc_block(nblocks, xg);

          if (xg->missing_values_present)
            alloc_missing_block(nblocks, xg);
        }

      } else {  /* -only was used */
        if (nrows >= xg->nrows)
          break;
      }
    }
  }

/*
 * Close the data file
*/
  if (fclose(fp) == EOF)
    fprintf(stderr, "read_array: error in fclose");

  if (xg->file_read_type == read_all)
    xg->nrows = nrows;

  fprintf(stderr, "size of data: %d x %d\n", xg->nrows, xg->ncols);

  if ( nitems != xg->nrows * xg->ncols_used )
  {
    (void) fprintf(stderr, "read_array: nrows*ncols != nitems read\n");
    (void) fprintf(stderr, "(nrows %d, ncols %d, nitems read %d)\n",
      xg->nrows, xg->ncols_used, nitems);
    exit(0);
  }
  else if (nitems == 0)
  {
    (void) fprintf(stderr, "No data read\n");
    exit(0);
  }
  else
  {
    /*
     * If we haven't yet encountered a missing value, free up
     * the whole matrix.
    */
    if (!xg->missing_values_present)
      xg->is_missing = (short **) NULL;

    if (xg->file_read_type == read_all) {
      /*
       * One last XtFree and XtRealloc to make raw_data take up exactly
       * the amount of space it needs.
      */
      for (i=xg->nrows; i<BLOCKSIZE*nblocks; i++)
        XtFree((XtPointer) xg->raw_data[i]);
      xg->raw_data = (float **) XtRealloc((XtPointer) xg->raw_data,
        (Cardinal) xg->nrows * sizeof(float *));

      if (xg->missing_values_present) {
        for (i=xg->nrows; i<BLOCKSIZE*nblocks; i++)
          XtFree((XtPointer) xg->is_missing[i]);
        xg->is_missing = (short **) XtRealloc((XtPointer) xg->is_missing,
          (Cardinal) xg->nrows * sizeof(short *));
      }
    }

    /*
     * If the data contains only one column, add a second,
     * the numbers 1:nrows -- and let the added column be
     * the first column?
    */
    xg->single_column = False;
    if (xg->ncols_used == 1)
    {
      xg->single_column = True;
      xg->ncols_used = 2;
      xg->ncols = 3;
      for (i=0; i<xg->nrows; i++)
      {
        xg->raw_data[i] = (float *) XtRealloc(
          (XtPointer) xg->raw_data[i],
          (Cardinal) 3 * sizeof(float));
        xg->raw_data[i][1] = xg->raw_data[i][0] ;
        xg->raw_data[i][0] = (float) (i+1) ;

        /* And populate a column of missing values with 0s, if needed */
        if (xg->missing_values_present)
        {
          xg->is_missing[i] = (short *) XtRealloc(
            (XtPointer) xg->is_missing[i],
            (Cardinal) 3 * sizeof(short));
          xg->is_missing[i][1] = 0 ;
        }
      }
    }
  }
}
Example #13
0
File: umenus.c Project: oeli/yafra
/*F--------------------------------------------------------------------------
 *  Function:	xUImenudown ()
 *					-effective popdown a menu
 *  				-also popdown other satellite BM menus 
 *  In:			-std cb params
 *  out:			-
 *  Return:		-
 *---------------------------------------------------------------------------
 */
XtCallbackProc xUImenudown( Widget w, XtPointer closure, XtPointer data)
{
	extern MENU       menu[];
	extern int        aktmenuz;
	extern int        aktmenu[];
	extern int        aktfield[];
	extern int        zufield[];
	extern int        holdfield;
	extern Boolean    allmenuflag;
	extern unsigned char actiontoggle;
	extern TWINLIST	*twinList;

	int		i, f, x, nr;
	MENU		*a, *v;
	Arg		wargs[4];
	char		*ptext;

	/*--- Is a menu open ? ------*/
	if (aktmenuz == -1) 
		return ; 

/*???????	x = zufield[aktmenuz];  */
	/*--- field of present menu */
	x = aktfield[aktmenuz];

	/*--- close present menu ----*/
	v = (MENU *)closure;
	v->enter = TRUE;
	v->editfeld = TRUE;
	v->openedmenu = FALSE;				/* is checked for existing window */
	aktmenuz--;
	XtPopdown(v->popup);

	if (aktmenuz == -1)
		{
		/*--- set sensitive all enabled menus -------*/
		xUIpulldownSensitive( True );
		xUIglobmenuSensitive( True );
		}
	else
		{
		/*--- update behaviour of previous menu -------*/
		nr = aktmenu[aktmenuz];
		a = &menu[nr];
		f = aktfield[aktmenuz];
		/*--- re-enable editing --*/
		a->editfeld = TRUE;
		a->alreadywrite = FALSE;
		xUImenufeld(a, a->field[f], TRUE, TRUE, FALSE, TRUE);
		/*--- get text of search field ------*/
		for ( i=0;  i < v->anz;  i++ )
			{
			if (v->suchfields[i] == TRUE)
/*?????			if (v->buttontype[x] == SELECTFIELD || v->buttontype[x] == SEDITFIELD) */
				{
				ptext = XmTextGetString( v->field[i] );
				XtSetArg(wargs[0], XmNvalue, ptext );
				XtSetValues(a->field[f], wargs, 1);
				XtFree((void *)ptext);
				}
			}
		holdfield = f;
		}
	

	/*--- free unless specified by flag,  output is special because of optional fields -*/
	if ((!allmenuflag) || (v->typ == _OUTPUT))
		{
		/*--- current menu ----*/
		XtDestroyWidget(v->popup);
		XtFree((void *)v->field);
		XtFree((void *)v->pushbutton);
		v->pushbutton = NULL;
		v->popup = NULL;
		v->field = NULL;
		}

	/*--- free Twin select widget ---*/
	xUICtwinDestroy( twinList );
	twinList = 0;
}
Example #14
0
/******************************************************************************
 * Function:	int FormatChunksToXmString ()
 *
 * Parameters:
 *               *ret_list may be NULL when called
 *
 * Returns:	0 if successful, -1 if errors
 *
 * errno Values:
 *
 * Purpose:	Take some rich text chunks and turn it into an XmString.
 *
 ******************************************************************************/
static int
FormatChunksToXmString(
    DtHelpDispAreaStruct *pDAS,
    Boolean		  free_flag,
    void		**title_chunks,
    XmString		 *ret_title,
    XmFontList		 *ret_list,
    Boolean		 *ret_mod )
{
    int			 result = 0;
    int			 i;
    long		 j;
    int			 quarkCount;
    long		 chunkType;
    long		 myIdx;
    _DtCvPointer	 fontPtr;
    char		*charSet;
    const char		*strChunk;
    char		 buffer[16];
    _DtHelpFontHints		 fontSpecs;
    XmFontContext	 fontContext;
    XmString		 partTitle;
    XmString		 newTitle;
    XrmQuark		 charSetQuark;
    XrmName		 myCharSetQuarks[20];
    XrmName		 xrmName[_CEFontAttrNumber];
    Boolean		 myMore;

    /*
     * Initialize the pointers.
     */
    *ret_title = NULL;
    *ret_mod   = False;

    if (title_chunks == NULL)
	return -1;

    /*
     * initialize the font context
     */
    _DtHelpCeCopyDefFontAttrList(&fontSpecs);
    if ( NULL != *ret_list )
      {
        if (XmFontListInitFontContext (&fontContext, *ret_list) == False)
            result = -1;
        else 
          {
            XFontStruct *myFontStruct;
            /*
             * quarkize all the character sets found.
             */
            quarkCount = 0;
            do
              {
                myMore = XmFontListGetNextFont (fontContext, &charSet,
                                                                &myFontStruct);
                if (myMore)
                  {
                    myCharSetQuarks[quarkCount++] = 
                                                XrmStringToQuark (charSet);
                    XtFree (charSet);
                  }
              } while (myMore);
    
            XmFontListFreeFontContext (fontContext);
          }
      } /* if NULL != *ret_list */
    else
      { /* if NULL == *ret_list */
         quarkCount = 0;
         myCharSetQuarks[0] = 0;
      }

    /*
     * Build the XrmString based on the segments.
     * The format of the returned information is
     *		'DT_HELP_CE_CHARSET  locale  string'
     *		'DT_HELP_CE_FONT_PTR fontptr string'
     *		'DT_HELP_CE_SPC      spc'
     *		'DT_HELP_CE_STRING   string' - uses last specified
     *                                         charset/font_ptr.
     *
     * The order and manner in which the title_chunks are processed
     * is known and depended upon in several locations.
     * Do not change this without changing the other locations.
     * See the _DtHelpFormatxxx() routines and the ones that
     * create the title_chunk arrays in FormatSDL.c and FormatCCDF.c
     */
    myIdx = __DtHelpDefaultFontIndexGet(pDAS);
    _DtHelpCopyDefaultList(xrmName);
    for (i = 0; result == 0 && title_chunks[i] != DT_HELP_CE_END; i++)
      {
        /*
         * create a string for the char set and a quark for it.
         */
	chunkType = (long) title_chunks[i++];

        /*
	 * i now points to the first value after the type
	 */
	if (chunkType & DT_HELP_CE_CHARSET)
	  {
	    char *charSet;
	    char *lang = (char *) title_chunks[i];

	    /*
	     * test to see if the locale is in a lang.codeset form
	     */
	    if (_DtHelpCeStrchr(lang, ".", 1, &charSet) == 0)
	      {
		*charSet = '\0';
		charSet++;
	      }
	    else
	      {
		charSet = lang;
		lang    = NULL;
	      }

	    /*
	     * resolve/load the font for the default fonts
	     */
	    _DtHelpDAResolveFont(pDAS, lang, charSet, fontSpecs, &fontPtr);
	    myIdx = (long) fontPtr;
	    if (lang != NULL)
	      {
		charSet--;
		*charSet = '.';
	      }

	    if (free_flag)
	        free(title_chunks[i]);

	    /*
	     * move the i to point to the string.
	     */
	    i++;
	  }
	else if (chunkType & DT_HELP_CE_FONT_PTR)
	  {
	    /*
	     * get the default font for the language and code set.
	     */
	    (void) __DtHelpFontCharSetQuarkGet(pDAS, (long)title_chunks[i],
					&xrmName[_DT_HELP_FONT_CHAR_SET]);
	    (void) __DtHelpFontLangQuarkGet(pDAS, (long)title_chunks[i],
					&xrmName[_DT_HELP_FONT_LANG_TER]);
	    (void) __DtHelpFontIndexGet(pDAS, xrmName, &myIdx);

	    /*
	     * move the i to point to the string.
	     */
	    i++;
	  }

        /*
	 * the i point spc or string.
	 */
	if (chunkType & DT_HELP_CE_SPC)
	  {
	    j        = (long) title_chunks[i];
	    strChunk = _DtHelpDAGetSpcString(pDAS->spc_chars[j].spc_idx);
	    fontPtr  = pDAS->spc_chars[j].font_ptr;

	    /*
	     * get the default font for the language and code set.
	     */
	    (void) __DtHelpFontCharSetQuarkGet(pDAS, (long)fontPtr,
					&xrmName[_DT_HELP_FONT_CHAR_SET]);
	    (void) __DtHelpFontLangQuarkGet(pDAS, (long)fontPtr,
					&xrmName[_DT_HELP_FONT_LANG_TER]);
	    (void) __DtHelpFontIndexGet(pDAS, xrmName, &myIdx);
	  }
	else /* if (chunkType & _DT_HELP_CE_STRING) */
	    strChunk = (char *) title_chunks[i];

	sprintf(buffer, "%ld", myIdx);
	charSetQuark = XrmStringToQuark(buffer);

        j = 0;
        while (j < quarkCount && myCharSetQuarks[j] != charSetQuark)
            j++;

        /*
         * If we didn't find a matching character set,
         * add it to the list.
         */
        if (j >= quarkCount)
          {
	    /* Copy the input list so XmFontListAppendEntry can mangle it. */
	    /* But only do it once! */
	    if (False == *ret_mod)
	       *ret_list = XmFontListCopy(*ret_list);

	    if (myIdx < 0)
	      {
		XFontSet fontSet = __DtHelpFontSetGet(pDAS->font_info, myIdx);
                XmFontListEntry fontEntry;

		fontEntry = XmFontListEntryCreate (buffer,
						XmFONT_IS_FONTSET,
						(XtPointer) fontSet);
		*ret_list = XmFontListAppendEntry (*ret_list, fontEntry);
		XmFontListEntryFree (&fontEntry);
	      }
	    else
	      {
		XFontStruct *fontStruct =
				__DtHelpFontStructGet(pDAS->font_info, myIdx);
                XmFontListEntry fontEntry;

		fontEntry = XmFontListEntryCreate (buffer,
						XmFONT_IS_FONT,
						(XtPointer) fontStruct);
		*ret_list = XmFontListAppendEntry (*ret_list, fontEntry);
		XmFontListEntryFree (&fontEntry);
	      }

           *ret_mod = True;
            if (*ret_list == NULL)
                result = -1;

            myCharSetQuarks[quarkCount++] = charSetQuark;
          }

        /*
         * add this segment to the XmString.
         */
        if (result == 0)
          {
            if (*ret_title == NULL)
                *ret_title = XmStringGenerate ((char *) strChunk, buffer, 
					       XmCHARSET_TEXT, NULL);
            else
              {
                partTitle = XmStringGenerate ((char *) strChunk, buffer,
					      XmCHARSET_TEXT, NULL);

                newTitle = XmStringConcat (*ret_title, partTitle);

                XmStringFree (*ret_title);
                XmStringFree (partTitle);
                *ret_title = newTitle;
              }

            /*
             * if a newline was specified,
             * replace it with a blank.
             */
            if (*ret_title != NULL && (chunkType & DT_HELP_CE_NEWLINE))
              {
                partTitle = XmStringGenerate (" ", buffer, XmCHARSET_TEXT, NULL);
                newTitle = XmStringConcat (*ret_title, partTitle);
                XmStringFree (*ret_title);
                XmStringFree (partTitle);
                *ret_title = newTitle;
              }

            if (*ret_title == NULL)
                result = -1;
          }

	if (free_flag && (chunkType & DT_HELP_CE_STRING))
	    free(title_chunks[i]);
      }
    /*
     * deallocate the memory.
     */
    if (free_flag) free(title_chunks);
    return result;
}
Example #15
0
void *CoWowMotif::CreateList( const char *title, const char *texts, int textsize,
			      void (action_cb)( void *, char *),
			      void (cancel_cb)( void *),
			      void *parent_ctx,
			      int show_apply_button)
{
  Arg	    args[15];
  XmString cstr;
  Widget mainwindow;
  Widget ok_button;
  Widget cancel_button;
  Widget form;
  char *name_p;
  int i;
  wow_tListCtx ctx;
  XmFontList fontlist;
  XFontStruct *font;
  XmFontListEntry fontentry;

  ctx = (wow_tListCtx) calloc( 1, sizeof(*ctx));
  ctx->action_cb = action_cb;
  ctx->cancel_cb = cancel_cb;
  ctx->parent_ctx = parent_ctx;
  
  i=0;
  XtSetArg( args[i], XmNiconName, title); i++;

  ctx->toplevel = XtCreatePopupShell (
        title, topLevelShellWidgetClass, m_parent, args, i);

  // Set default fontlist
  font = XLoadQueryFont( XtDisplay(ctx->toplevel),
	      "-*-Helvetica-Bold-R-Normal--12-*-*-*-P-*-ISO8859-1");
  fontentry = XmFontListEntryCreate( (char*) "tag1", XmFONT_IS_FONT, font);
  fontlist = XmFontListAppendEntry( NULL, fontentry);
  XtFree( (char *)fontentry);

  i=0;
  XtSetArg( args[i], XmNbuttonFontList, fontlist); i++;
  XtSetArg( args[i], XtNallowShellResize, TRUE); i++;
  XtSetValues( ctx->toplevel, args, i);

  mainwindow = XmCreateMainWindow( ctx->toplevel, (char*) "mainWindow", NULL, 0);
  XtManageChild( mainwindow);

  i=0;
  XtSetArg(args[i],XmNwidth, 200);i++;
  XtSetArg(args[i],XmNheight, 400);i++;
  XtSetArg(args[i],XmNresizePolicy,XmRESIZE_NONE); i++;

  form = XmCreateForm( mainwindow, (char*) "form", args, i);
  XtManageChild( form);

  cstr = XmStringCreateLtoR( (char*) "Ok", XmSTRING_DEFAULT_CHARSET);

  i=0;
  XtSetArg( args[i], XmNbottomAttachment, XmATTACH_FORM); i++;
  XtSetArg( args[i], XmNbottomOffset, 20); i++;
  XtSetArg( args[i], XmNleftAttachment, XmATTACH_FORM); i++;
  XtSetArg( args[i], XmNleftOffset, 20); i++;
  XtSetArg( args[i], XmNwidth, 50); i++;
  XtSetArg( args[i], XmNlabelString, cstr); i++;

  ok_button = XmCreatePushButton( form, (char*) "okButton", args, i);
  XtAddCallback( ok_button, XmNactivateCallback,
		(XtCallbackProc) list_ok_cb, ctx);
  XtManageChild( ok_button);

  XmStringFree( cstr);

  cstr = XmStringCreateLtoR( (char*) "Cancel", XmSTRING_DEFAULT_CHARSET);

  i=0;
  XtSetArg( args[i], XmNbottomAttachment, XmATTACH_FORM); i++;
  XtSetArg( args[i], XmNbottomOffset, 20); i++;
  XtSetArg( args[i], XmNrightAttachment, XmATTACH_FORM); i++;
  XtSetArg( args[i], XmNrightOffset, 20); i++;
  XtSetArg( args[i], XmNwidth, 50); i++;
  XtSetArg( args[i], XmNlabelString, cstr); i++;

  cancel_button = XmCreatePushButton( form, (char*) "okButton", args, i);
  XtAddCallback( cancel_button, XmNactivateCallback,
		(XtCallbackProc) list_cancel_cb, ctx);
  XtManageChild( cancel_button);

  XmStringFree( cstr);

  i = 0;
  XtSetArg( args[i], XmNdefaultButton, ok_button); i++;
  XtSetArg( args[i], XmNcancelButton, cancel_button); i++;
  XtSetValues( form, args, i);

  i=0;
  XtSetArg( args[i], XmNbottomAttachment, XmATTACH_WIDGET); i++;
  XtSetArg( args[i], XmNbottomWidget, ok_button); i++;
  XtSetArg( args[i], XmNbottomOffset, 15); i++;
  XtSetArg( args[i], XmNrightAttachment, XmATTACH_FORM); i++;
  XtSetArg( args[i], XmNrightOffset, 15); i++;
  XtSetArg( args[i], XmNtopAttachment, XmATTACH_FORM); i++;
  XtSetArg( args[i], XmNtopOffset, 15); i++;
  XtSetArg( args[i], XmNleftAttachment, XmATTACH_FORM); i++;
  XtSetArg( args[i], XmNleftOffset, 15); i++;
  XtSetArg( args[i], XmNselectionPolicy, XmSINGLE_SELECT); i++;
  XtSetArg( args[i], XmNfontList, fontlist); i++;
  ctx->list = XmCreateScrolledList( form, (char*) "scrolledList", args, i);
  XtAddCallback( ctx->list, XmNdefaultActionCallback,
		(XtCallbackProc) list_action_cb, ctx);

  XmFontListFree( fontlist);
  XtManageChild( ctx->list);

  name_p = (char *)texts;
  i = 0;
  while ( strcmp( name_p, "") != 0) {
    cstr = XmStringCreateSimple( name_p);
    XmListAddItemUnselected( ctx->list, cstr, 0);
    XmStringFree(cstr);	  
    name_p += textsize;
    i++;
  }

  ctx->texts = (char *) calloc( i+1, textsize);
  ctx->textsize = textsize;
  memcpy( ctx->texts, texts, (i+1) * textsize); 
  XtPopup( ctx->toplevel, XtGrabNone);

  // Set input focus to the scrolled list widget
  XmProcessTraversal( ctx->list, XmTRAVERSE_CURRENT);


  return ctx;
}
Example #16
0
void filesbokCB(Widget widget, Exc_data * ed, XtPointer call_data)
{
    XmFileSelectionBoxCallbackStruct	*ptr;
    char				*file = NULL, *dir = NULL, *tmpfile;
    int					r, ans = 0;
    char				*msg1;
    char				*msg2;

    msg1 = GETMESSAGE(2, 4, "The selected file exists. Overwrite?");
    msg2 = GETMESSAGE(2, 6, "Failed to open the selected file.");

    ptr = (XmFileSelectionBoxCallbackStruct *) call_data;

    file = (char *)  _XmStringUngenerate((XmString) ptr->value, NULL,
					  XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
    if (!file) {
	return;
    }

    dir = (char *)  _XmStringUngenerate((XmString) ptr->dir, NULL,
					  XmMULTIBYTE_TEXT, XmMULTIBYTE_TEXT);
    if (!dir) {
	return;
    } else {
	if (*file != '/') {
	    if ((tmpfile = XtMalloc(strlen(dir) + 1 + strlen(file) + 1))
		== NULL) {
		excerror(ed, EXCERRMALLOC, "filesbokCB", "exit");
	    }
	    sprintf(tmpfile, "%s/%s", dir, file);
	    XtFree(file);
	    file = tmpfile;
	}
    }

    r = fopencheck(file, dir, ed->bdfmode);
    if (r == 0) {/* no problem */
	/*fprintf(stderr, "%s will be opened\n", file);*/
    } else if (r == 1) { /* file exist at export function */
	AskUser(widget, ed, msg1, &ans, "warning");
	if (ans != 1) { /* overwrite cancel */
	    freeStrings(dir, file);
	    return;
	}
    } else { /* file will not be opened */
	AskUser(widget, ed, msg2, &ans, "error");
	freeStrings(dir, file);
	return;
    }
    ed->bdffile = (char *) malloc(strlen(file) + 1);
    strcpy(ed->bdffile, file);
    freeStrings(dir, file);
    XtUnmanageChild(widget);
    if (ed->function == EXPORT)
    {
	createbdf(ed);
    } else if (ed->function == IMPORT)
    {
	PopupSelectXLFD(ed->toplevel);
    }
}
Example #17
0
int CoWowMotif::DisplayWarranty()
{
    char    text[4000];
    Arg	    arg[12];
    Widget  question_widget;
    XmString CStr2, TitleStr, okstr, cancelstr, helpstr;
    wow_t_question_cb *cbdata;
    XmFontList fontlist;
    XFontStruct *font;
    XmFontListEntry fontentry;
    char 	title[80];
    FILE 	*fp;
    int 	i;
    char 	fname[256];

    // Display only once
    if ( HideWarranty())
      return 1;

    sprintf( fname, "$pwr_exe/%s/acceptlicense.txt", lng_get_language_str());
    dcli_translate_filename( fname, fname);

    fp = fopen( fname, "r");
    if ( !fp) {
      strcpy( fname, "$pwr_exe/en_us/acceptlicense.txt");
      dcli_translate_filename( fname, fname);
      fp = fopen( fname, "r");
      if ( !fp) return 1;
    }

    for ( i = 0; i < (int)sizeof(text) - 1; i++) {
      text[i] = fgetc( fp);
      if ( text[i] == EOF)
	break;
    }
    text[i] = 0;
    fclose( fp);

    strcpy( title, lng_translate("Accept License Terms"));

    // Set default fontlist
    font = XLoadQueryFont( XtDisplay(m_parent),
	      "-*-Helvetica-Bold-R-Normal--12-*-*-*-P-*-ISO8859-1");
    fontentry = XmFontListEntryCreate( (char*) "tag1", XmFONT_IS_FONT, font);
    fontlist = XmFontListAppendEntry( NULL, fontentry);
    XtFree( (char *)fontentry);
    
    CStr2 = XmStringCreateLtoR( text, XmSTRING_DEFAULT_CHARSET);
    TitleStr = XmStringCreateLtoR( title, XmSTRING_DEFAULT_CHARSET);    
    okstr = XmStringCreateLtoR( lng_translate( "I Accept"), XmSTRING_DEFAULT_CHARSET );    
    cancelstr = XmStringCreateLtoR( lng_translate( "Quit"), XmSTRING_DEFAULT_CHARSET );    
    helpstr = XmStringCreateLtoR( lng_translate( "Show License"), XmSTRING_DEFAULT_CHARSET );    
    XtSetArg(arg[0],XmNheight,75);
    XtSetArg(arg[1],XmNwidth,700);
    XtSetArg(arg[2],XmNmessageString, CStr2);
    XtSetArg(arg[3],XmNx,400);
    XtSetArg(arg[4],XmNy,300);
    XtSetArg(arg[5],XmNdialogTitle,TitleStr);
    XtSetArg(arg[6], XmNokLabelString, okstr);
    XtSetArg(arg[7], XmNcancelLabelString, cancelstr);
    XtSetArg(arg[8], XmNhelpLabelString, helpstr);
    XtSetArg(arg[9], XmNbuttonFontList, fontlist);
    XtSetArg(arg[10], XmNlabelFontList, fontlist);
    XtSetArg(arg[11], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL);

    cbdata = (wow_t_question_cb *) XtCalloc( 1, sizeof(*cbdata));
    cbdata->questionbox_ok = warranty_ok_cb;
    cbdata->questionbox_cancel = warranty_cancel_cb;
    cbdata->questionbox_help = warranty_help_cb;
    cbdata->ctx = 0;
    cbdata->data = (void *)this;

    question_widget = XmCreateMessageDialog( m_parent,(char*) "questionDialog",arg, 12);
    XtAddCallback( question_widget, XmNokCallback,
		(XtCallbackProc) question_ok_cb, cbdata);
    XtAddCallback( question_widget, XmNcancelCallback, 
		(XtCallbackProc) question_cancel_cb, cbdata);
    XtAddCallback( question_widget, XmNhelpCallback, 
		(XtCallbackProc) question_help_cb, cbdata);

    XmStringFree( CStr2);
    XmStringFree( TitleStr);
    XmStringFree( okstr);
    XmStringFree( cancelstr);
    XmStringFree( helpstr);
    XmFontListFree( fontlist);
   
    XtManageChild( question_widget);	       
    return 1;
}
Example #18
0
  int
main(int argc, char **argv)
{
    Widget              ScrollWin, Container, *IconGad;   
    int			i;
    Cardinal		n;
    Arg			args[MAX_ARGS];
    Dimension		x_size, y_size;

    CommonTestInit(argc, argv);

    n = 0;
    XtSetArg( args[n], XmNx, 20 ); n++;
    ScrollWin = XmCreateScrolledWindow(Shell1, "ScrollWin7", args, n);
    XtManageChild(ScrollWin);

    XtSetArg(args[n], XmNselectionPolicy, XmMULTIPLE_SELECT); n++;
    XtSetArg(args[n], XmNspatialStyle, XmNONE ); n++;
    Container = XmCreateContainer(ScrollWin, "Container7", args, n);
    XtManageChild(Container);

    /* Add a bunch of Icon Gadgets */

    IconGad = (Widget*) XtMalloc(NUM_ELEMS * sizeof(Widget));

    /* Put some pixmaps in the Container */
    for (i = 0; i <  NUM_PIXMAP; i++) {
	char        IconName[20] ;
	XmString   icon_name;
	Pixmap	pixmap;

	n = 0 ;
	sprintf(IconName, "IconGad%d", i);
	icon_name = XmStringGenerate(IconName, NULL, XmCHARSET_TEXT, NULL); 

   	/* make icons from pixmap files */

	pixmap = XmGetPixmap(screen, BitmapPaths[i],
	  BlackPixelOfScreen(screen),
	  WhitePixelOfScreen(screen));

	if (!pixmap)
	{
	  printf("Can't make pixmap for file %s!\n",
	    BitmapPaths[i]);
	  exit(1);
	}

	XtSetArg(args[n], XmNx, PIXEL_X(i) ); n++;
	XtSetArg(args[n], XmNy, PIXEL_Y(i) ); n++;
	XtSetArg(args[n], XmNlabelString, icon_name); n++;
	XtSetArg(args[n], XmNlargeIconPixmap, pixmap); n++;

	IconGad[i] = XmCreateIconGadget(Container, IconName, args, n);
        XtManageChild(IconGad[i]);
	XmStringFree(icon_name);
    }

    /* Put some labels in the Container */
    for (i = NUM_PIXMAP; i <  NUM_ELEMS; i++) {
	char        LabelName[20] ;
	XmString   label_name;

	n = 0 ;
	sprintf(LabelName, "LabelName%d", i);
	label_name = XmStringGenerate(LabelName, NULL, XmCHARSET_TEXT, NULL); 

	XtSetArg(args[n], XmNx, PIXEL_X(i) ); n++;
	XtSetArg(args[n], XmNy, PIXEL_Y(i) ); n++;
	XtSetArg(args[n], XmNlabelString, label_name); n++;
	XtSetArg(args[n], XmNlabelType, XmSTRING); n++;

	IconGad[i] =
		XmCreateIconGadget(Container, LabelName, args, n);
        XtManageChild(IconGad[i]);
	XmStringFree(label_name);
    }

    XtRealizeWidget(Shell1);

    /* Find out the default size for X and Y */
    n = 0;
    XtSetArg( args[n], XmNwidth, &x_size ); n++;
    XtSetArg( args[n], XmNheight, &y_size ); n++;
    XtGetValues( ScrollWin, args, n );

    /*************************
     * Assertions begin
     */

    /* Assertions 1 and 2 */
    n = 0;
    XtSetArg( args[n], XmNwidth, 175 ); n++;
    XtSetValues( ScrollWin, args, n );
    CommonPause();
    RestoreXY( ScrollWin, x_size, y_size );
    UnselectAll( Container );

    /* Assertions 3 and 4 */
    n = 0;
    XtSetArg( args[n], XmNwidth, 400 ); n++;
    XtSetValues( ScrollWin, args, n );
    CommonPause();
    RestoreXY( ScrollWin, x_size, y_size );
    UnselectAll( Container );

    /* Assertions 5 and 6 */
    n = 0;
    XtSetArg( args[n], XmNheight, 400 ); n++;
    XtSetValues( ScrollWin, args, n );
    CommonPause();
    RestoreXY( ScrollWin, x_size, y_size );
    UnselectAll( Container );

    /* Assertions 7 and 8 */
    CommonPause();

    XtAppMainLoop(app_context);


    for ( i=0; i < NUM_ELEMS; i++ )
      XtDestroyWidget( IconGad[i] );

    XtDestroyWidget( Container );
    XtDestroyWidget( ScrollWin );
    XtFree( (char *)IconGad );

}
Example #19
0
/************************************************************************
 * PrintOutputSetPageMargin
 *	Set the contents of the specified page margin
 ************************************************************************/
void
PrintOutputSetPageMargin(
			PrintOutput *pOutput,
			_DtPrintMarginEnum which,
			const char *margin,
			Boolean *parseError
			)
{
    int		pixels = 0;
    XtEnum	xtParseError = FALSE;
    char	*marginString = XtNewString(margin);

    if (parseError)
      *parseError = FALSE;

    switch (which)
    {
	case DTPRINT_OPTION_MARGIN_TOP:
          pixels = XmConvertStringToUnits(
					XtScreenOfObject(pOutput->pShell),
					marginString,
					XmVERTICAL,
					XmPIXELS,
					&xtParseError);
	  if (!xtParseError && pixels > 0)
	    pOutput->marginTop = pixels;
	  break;
	case DTPRINT_OPTION_MARGIN_RIGHT:
          pixels = XmConvertStringToUnits(
					XtScreenOfObject(pOutput->pShell),
					marginString,
					XmHORIZONTAL,
					XmPIXELS,
					&xtParseError);
	  if (!xtParseError && pixels > 0)
	    pOutput->marginRight = pixels;
	  break;
	case DTPRINT_OPTION_MARGIN_BOTTOM:
          pixels = XmConvertStringToUnits(
					XtScreenOfObject(pOutput->pShell),
					marginString,
					XmVERTICAL,
					XmPIXELS,
					&xtParseError);
	  if (!xtParseError && pixels > 0)
	    pOutput->marginBottom = pixels;
	  break;
	case DTPRINT_OPTION_MARGIN_LEFT:
          pixels = XmConvertStringToUnits(
					XtScreenOfObject(pOutput->pShell),
					marginString,
					XmHORIZONTAL,
					XmPIXELS,
					&xtParseError);
	  if (!xtParseError && pixels > 0)
	    pOutput->marginLeft = pixels;
	  break;
	default:
	  return;
    }

    if (!xtParseError)
      _poSetInnerPageDimensions(
			pOutput,
			pOutput->marginTop,
			pOutput->marginRight,
			pOutput->marginBottom,
			pOutput->marginLeft);
    else
      *parseError = TRUE;

    XtFree(marginString);
}
Example #20
0
void XtRemoveCallbacks (
    Widget	    widget,
    _Xconst char*   name,
    XtCallbackList  xtcallbacks)
{
    InternalCallbackList *callbacks;
    Widget hookobj;
    int i;
    InternalCallbackList icl;
    XtCallbackList cl, ccl, rcl;
    XtAppContext app = XtWidgetToApplicationContext(widget);

    LOCK_APP(app);
    callbacks = FetchInternalList(widget, name);
    if (!callbacks) {
	XtAppWarningMsg(app,
	       XtNinvalidCallbackList,XtNxtRemoveCallback,XtCXtToolkitError,
              "Cannot find callback list in XtRemoveCallbacks",
	      (String *)NULL, (Cardinal *)NULL);
	UNLOCK_APP(app);
	return;
    }

    icl = *callbacks;
    if (!icl) {
	UNLOCK_APP(app);
	return;
    }

    i = icl->count;
    cl = ToList(icl);
    if (icl->call_state) {
	icl->call_state |= _XtCBFreeAfterCalling;
	icl = (InternalCallbackList)__XtMalloc(sizeof(InternalCallbackRec) +
					     sizeof(XtCallbackRec) * i);
	icl->count = i;
	icl->call_state = 0;
    }
    ccl = ToList(icl);
    while (--i >= 0) {
	*ccl++ = *cl;
	for (rcl=xtcallbacks; rcl->callback; rcl++) {
	    if (cl->callback == rcl->callback && cl->closure == rcl->closure) {
		ccl--;
		icl->count--;
		break;
	    }
	}
	cl++;
    }
    if (icl->count) {
	icl = (InternalCallbackList)
	    XtRealloc((char *)icl, (sizeof(InternalCallbackRec) +
				    sizeof(XtCallbackRec) * icl->count));
	icl->is_padded = 0;
	*callbacks = icl;
    } else {
	XtFree((char *)icl);
	*callbacks = NULL;
    }
    hookobj = XtHooksOfDisplay(XtDisplayOfObject(widget));
    if (XtHasCallbacks(hookobj, XtNchangeHook) == XtCallbackHasSome) {
	XtChangeHookDataRec call_data;

	call_data.type = XtHremoveCallbacks;
	call_data.widget = widget;
	call_data.event_data = (XtPointer) name;
	XtCallCallbackList(hookobj,
		((HookObject)hookobj)->hooks.changehook_callbacks,
		(XtPointer)&call_data);
    }
    UNLOCK_APP(app);
} /* XtRemoveCallbacks */
Example #21
0
static void SetRateCB(Widget w, XtPointer closure,XtPointer call_data)
{
	char *text,*tag;
	float rateVal;
	Boolean UpdateRequired;
	
	
	text = XmTextFieldGetString(rate_tag);
	puts(text);
   	if(ParseRateParTag(text,&tag,rate_tag,rate_dlg,cur_rpar))
	{
		XtFree(text);   
		return ;
	}
	
	tag=strdup(tag);
	XtFree(text);
	
	text = XmTextFieldGetString(rate_rate);
	
	if(ParseRate(text,&rateVal))
	{
		free(tag);   
		XtFree(text);
		ShowErrorDialog("Rate must be a positive number !",rate_dlg);
		XmProcessTraversal(rate_rate,XmTRAVERSE_CURRENT);			
		return ;
	} 
	
	XtFree(text);

    if(cur_rpar == NULL)
	{
		struct rpar_object * l_rpar;
		
		cur_rpar = (struct rpar_object *) emalloc(RPAOBJ_SIZE);
		cur_rpar->tag = NULL;
		cur_rpar->center.x = fix_x;
		cur_rpar->center.y = fix_y;
		cur_rpar->next = NULL;
		cur_rpar->layer = NewLayerList(CURRENTVIEWANDWHOLE,NULL);
		
		if (netobj->rpars == NULL)
			l_rpar = NULL;
		else
			for (l_rpar = netobj->rpars;l_rpar->next != NULL; l_rpar = l_rpar->next);
		
		if (l_rpar != NULL)
			l_rpar->next = cur_rpar;
		else
			netobj->rpars = cur_rpar;
		
		UpdateRequired=FALSE;
		
	}
	else
		ShowRpar(cur_rpar, CLEAR);
	
     XFlush(XtDisplay(rate_dlg));
	
     if(UpdateRequired)
	{
		ShowRate(FALSE);
	}	
	
     if(cur_rpar->tag != NULL)
		free(cur_rpar->tag);
	
     cur_rpar->tag=tag;
     cur_rpar->value=rateVal;
	
     if(UpdateRequired)
	{
		if (rate_visible)
			ShowRate(TRUE);
	}	
	
    ShowRpar(cur_rpar, OR);
    ClearRes();
    menu_action();	
    SetModify();
    HideRateChangeDialog();
}
Example #22
0
extern void
make_browselist(Calendar *c)
{
	int		ac;
	Arg		args[15];
	XmString	label_str;
	Widget		separator,
			button_form;
	Browselist	*bl = (Browselist *)c->browselist;
	Dimension	label_width;
	char		*title;

	if (!bl)
		return;

	title = XtNewString(catgets(c->DT_catd, 1, 963, 
				    "Calendar : Menu Editor"));
	bl->frame = XtVaCreatePopupShell("menu_editor_frame",
                xmDialogShellWidgetClass, c->frame,
		XmNdeleteResponse, 	XmDO_NOTHING,
                XmNtitle, title,
                XmNallowShellResize, 	True,
		XmNmappedWhenManaged, 	False,
		NULL);
	setup_quit_handler(bl->frame, blist_quit_handler, (caddr_t)bl);
	XtFree(title);

        bl->form = XtVaCreateWidget("menu_editor_form",
                xmFormWidgetClass, bl->frame,
                XmNautoUnmanage, 	False,
                XmNfractionBase, 	5,
                NULL);

	label_str = XmStringCreateLocalized(
				catgets(c->DT_catd, 1, 410, "User Name:"));
       	bl->username_label = XtVaCreateWidget("name_label",
		xmLabelGadgetClass, bl->form,
		XmNlabelString, 	label_str,
               	NULL);
	XmStringFree(label_str);

	ac = 0;
	XtSetArg(args[ac], XmNorientation, 	XmVERTICAL); 	++ac;
	XtSetArg(args[ac], XmNpacking, 		XmPACK_COLUMN); ++ac;
	XtSetArg(args[ac], XmNtopAttachment, 	XmATTACH_FORM); ++ac;
	XtSetArg(args[ac], XmNtopOffset, 	6); 		++ac;
	XtSetArg(args[ac], XmNrightAttachment, 	XmATTACH_FORM); ++ac;
	XtSetArg(args[ac], XmNrightOffset, 	5); 		++ac;
	bl->edit_rc_mgr = XmCreateRowColumn(bl->form, "edit_rc_mgr", args, ac);

	label_str = XmStringCreateLocalized(
				catgets(c->DT_catd, 1, 686, "Add Name"));
       	bl->add_button = XtVaCreateWidget("add_button",
		xmPushButtonWidgetClass, bl->edit_rc_mgr,
		XmNlabelString, 	label_str,
		XmNnavigationType, 	XmTAB_GROUP,
               	NULL);
	XmStringFree(label_str);
	XtAddCallback(bl->add_button, XmNactivateCallback,
				blist_addname, (XtPointer)c);

	label_str = XmStringCreateLocalized(
				catgets(c->DT_catd, 1, 687, "Remove Name"));
   	bl->remove_button = XtVaCreateWidget("remove_button",
		xmPushButtonWidgetClass, bl->edit_rc_mgr,
		XmNlabelString, 	label_str,
		XmNnavigationType, 	XmTAB_GROUP,
                NULL);
	XmStringFree(label_str);
        XtAddCallback(bl->remove_button, XmNactivateCallback, 
				blist_removenames, (XtPointer)c);
	ManageChildren(bl->edit_rc_mgr);

	XtVaGetValues(bl->username_label, XmNwidth, &label_width, NULL);

       	bl->username = XtVaCreateWidget("username",
		xmTextFieldWidgetClass, bl->form,
		XmNleftAttachment, 	XmATTACH_FORM,
		XmNleftOffset, 		label_width + 15,
		XmNrightAttachment, 	XmATTACH_WIDGET,
		XmNrightWidget, 	bl->edit_rc_mgr,
		XmNrightOffset, 	5,
		XmNtopAttachment,	XmATTACH_FORM,
		XmNtopOffset, 		5,
		XmNcolumns, 		40,
               	NULL);
	XtAddCallback(bl->username, XmNactivateCallback, blist_addname,
				(XtPointer)c);
	XtAddCallback(bl->username, XmNvalueChangedCallback, 
				bl_pending_change, (XtPointer)c);

	XtVaSetValues(bl->username_label,
		XmNbottomAttachment,    XmATTACH_OPPOSITE_WIDGET,
                XmNbottomWidget,        bl->username,
                XmNbottomOffset,        5,
                XmNrightAttachment,     XmATTACH_WIDGET,
                XmNrightWidget,         bl->username,
                XmNrightOffset,         5,
                NULL);

	label_str = XmStringCreateLocalized(
			catgets(c->DT_catd, 1, 688, "Browse Menu Items"));
       	bl->list_label = XtVaCreateWidget("list_label", 
		xmLabelWidgetClass, bl->form,
		XmNlabelString, 	label_str,
		XmNtopAttachment, 	XmATTACH_WIDGET,
		XmNtopWidget, 		bl->username,
		XmNtopOffset, 		10,
		XmNleftAttachment, 	XmATTACH_FORM,
		XmNleftOffset, 		5,
               	NULL);
	XmStringFree(label_str);

	bl->message = XtVaCreateWidget("message_text",
                xmLabelGadgetClass, 
		bl->form,
		XmNalignment, 		XmALIGNMENT_BEGINNING,
                XmNleftAttachment, 	XmATTACH_FORM,
		XmNleftOffset, 		5,
                XmNrightAttachment, 	XmATTACH_FORM,
		XmNrightOffset, 	5,
                XmNbottomAttachment, 	XmATTACH_FORM,
		XmNbottomOffset, 	5,
                NULL);

	button_form = XtVaCreateWidget("menu_editor_button_form_mgr",
                xmFormWidgetClass,
                bl->form,
                XmNautoUnmanage,        False,
                XmNfractionBase,        5,
                XmNhorizontalSpacing,   5,
                XmNleftAttachment,      XmATTACH_FORM,
                XmNleftOffset,          5,
                XmNrightAttachment,     XmATTACH_FORM,
                XmNrightOffset,         5,
                XmNbottomAttachment,    XmATTACH_WIDGET,
                XmNbottomWidget,        bl->message,
                XmNbottomOffset,        5,
                NULL);
	
	label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 655, "OK"));
	bl->ok_button = XtVaCreateWidget("ok_button",
		xmPushButtonWidgetClass,
		button_form,
		XmNlabelString, 	label_str,
		XmNleftAttachment, 	XmATTACH_POSITION,
		XmNleftPosition, 	0,
		XmNleftOffset, 		5,
		XmNrightAttachment, 	XmATTACH_POSITION,
		XmNrightPosition, 	1,
		XmNrightOffset, 	5,
		XmNbottomAttachment, 	XmATTACH_FORM,
                NULL);
	XmStringFree(label_str);
	XtAddCallback(bl->ok_button, XmNactivateCallback, blist_ok,
		      		(XtPointer)c);

	label_str = XmStringCreateLocalized(
				catgets(c->DT_catd, 1, 460, "Apply"));
	bl->apply_button = XtVaCreateWidget("apply_button",
		xmPushButtonWidgetClass,
		button_form,
		XmNlabelString, 	label_str,
		XmNleftAttachment, 	XmATTACH_POSITION,
		XmNleftPosition, 	1,
		XmNleftOffset, 		5,
		XmNrightAttachment, 	XmATTACH_POSITION,
		XmNrightPosition, 	2,
		XmNrightOffset, 	5,
		XmNbottomAttachment, 	XmATTACH_FORM,
                NULL);
	XmStringFree(label_str);
	XtAddCallback(bl->apply_button, XmNactivateCallback, blist_apply,
		      		(XtPointer)c);

	label_str = XmStringCreateLocalized(
				catgets(c->DT_catd, 1, 691, "Reset"));
        bl->reset_button = XtVaCreateWidget("reset_button",
		xmPushButtonWidgetClass,
		button_form,
		XmNlabelString, 	label_str,
		XmNleftAttachment, 	XmATTACH_POSITION,
		XmNleftPosition, 	2,
		XmNleftOffset, 		5,
		XmNrightAttachment, 	XmATTACH_POSITION,
		XmNrightPosition, 	3,
		XmNrightOffset, 	5,
		XmNbottomAttachment, 	XmATTACH_FORM,
                NULL);
	XmStringFree(label_str);
	XtAddCallback(bl->reset_button, XmNactivateCallback,
			blist_reset_cb, (XtPointer)c);

	label_str = XmStringCreateLocalized(
				catgets(c->DT_catd, 1, 923, "Cancel"));
        bl->cancel_button = XtVaCreateWidget("cancel_button",
	 	xmPushButtonWidgetClass,
		button_form,
		XmNlabelString, 	label_str,
		XmNleftAttachment, 	XmATTACH_POSITION,
		XmNleftPosition, 	3,
		XmNleftOffset, 		5,
		XmNrightAttachment, 	XmATTACH_POSITION,
		XmNrightPosition, 	4,
		XmNrightOffset, 	5,
		XmNbottomAttachment, 	XmATTACH_FORM,
                NULL);
	XmStringFree(label_str);
	XtAddCallback(bl->cancel_button, XmNactivateCallback, blist_cancel_cb,
				(XtPointer)c);

	label_str = XmStringCreateLocalized(catgets(c->DT_catd, 1, 77, "Help"));
        bl->help_button = XtVaCreateWidget("help_button",
		xmPushButtonWidgetClass,
		button_form,
		XmNlabelString, 	label_str,
		XmNleftAttachment, 	XmATTACH_POSITION,
		XmNleftPosition, 	4,
		XmNleftOffset, 		5,
		XmNrightAttachment, 	XmATTACH_POSITION,
		XmNrightPosition, 	5,
		XmNrightOffset, 	5,
		XmNbottomAttachment, 	XmATTACH_FORM,
                NULL);
	XmStringFree(label_str);
        XtAddCallback(bl->help_button, XmNactivateCallback, 
		(XtCallbackProc)help_cb, MENU_EDITOR_HELP_BUTTON);
        XtAddCallback(bl->form, XmNhelpCallback,
                (XtCallbackProc)help_cb, (XtPointer) MENU_EDITOR_HELP_BUTTON);

	ManageChildren(button_form);

	separator = XtVaCreateWidget("separator",
                xmSeparatorGadgetClass,
                bl->form,
                XmNleftAttachment,      XmATTACH_FORM,
                XmNrightAttachment,     XmATTACH_FORM,
                XmNbottomAttachment,   	XmATTACH_WIDGET,
                XmNbottomWidget,        button_form,
		XmNbottomOffset, 	5,
                NULL);
	ac = 0;
	XtSetArg(args[ac], XmNvisibleItemCount, 8); ++ac;
	XtSetArg(args[ac], XmNselectionPolicy, XmMULTIPLE_SELECT); ++ac;
	XtSetArg(args[ac], XmNdoubleClickInterval, 5); ++ac;
	bl->browse_list = (Widget)XmCreateScrolledList(bl->form, "browse_list",
						       args, ac);
        bl->browse_list_sw = XtParent(bl->browse_list);

	XtVaSetValues(bl->browse_list_sw,
                XmNvisualPolicy, 	XmVARIABLE,
                XmNtopAttachment, 	XmATTACH_WIDGET,
                XmNtopWidget, 		bl->list_label,
		XmNtopOffset, 		5,
                XmNleftAttachment, 	XmATTACH_OPPOSITE_WIDGET,
		XmNleftWidget, 		bl->list_label,
		XmNrightAttachment, 	XmATTACH_OPPOSITE_WIDGET,
		XmNrightWidget, 	bl->username,
		XmNrightOffset, 	5,
		XmNbottomAttachment, 	XmATTACH_WIDGET,
		XmNbottomWidget, 	separator,
		XmNbottomOffset,	5,
		XmNwidth, 50,
		NULL);
	XtManageChild(bl->browse_list);

        XtAddCallback(bl->browse_list, XmNmultipleSelectionCallback, 
				bl_list_selection_cb, (XtPointer)c);

	ManageChildren(bl->form);
	XtManageChild(bl->form);

        /*
	 * Set default button
	 */
        XtVaSetValues(bl->form, XmNcancelButton, bl->cancel_button, NULL);
        XmProcessTraversal(bl->username, XmTRAVERSE_CURRENT);
        XtVaSetValues(bl->form, XmNinitialFocus, bl->username, NULL);

	/*
	 * For storing the list of names
	 */
	if (!bl->blist_data)
		bl->blist_data = CmDataListCreate();
}
Example #23
0
static void createOneDHistActual(int newHisto)
{
   int countHisto, countNTu, countVar, ivar, ivarH, nBins, idh, uid, im, jn;
   int i, index, k, *ivk, ll, lastFixed;
   float from, to;
   double dfrom, dto;
   XmString *selectedItems;
   int *posListHisto, *posListNTu, *posListVar;
   char *str, category[24], x_label[20]; 
   nTuDDL *ddl;
   descrGenNtuple *dNTu;
   nTuBrowserInfo *nTuBr;
   varGenNtuple *var;
   Arg args[2];
   nTuBroHs1D *nTuH1;
   char *cDat;
   long pp; 


    if (HistoIsBrowserNtuInit == NULL) {
       hs_initialize("Mcfio Ntuple Browser");
       hs_histoscope(1);
       HistoIsBrowserNtuInit = 1;
       XtSetSensitive(McfioHsResetBtnW, True);
       hs_update();
       setTimer(500);
    }
    nTuBr = CurrentNTupleBrowserSelected;
    ddl = mcf_GetNTuByPtrID(CurrentNTupleBrowserSelected->id);
    if (ddl->descrNtu == NULL) dNTu = ddl->reference->descrNtu;
	    else dNTu = ddl->descrNtu;
    
    if (!XmListGetSelectedPos(OneDHistVariableListW, &posListVar, &countVar)) {
	DialogF(DF_WARN, OneDHistShellW, 1, "Please select a Variable",
		"Acknowledged");
	return;
    }
    ivarH = (*posListVar) - 1; ivar = ivarH -1;
    /*
    ** Get how many time we have to histogram the variable
    */
    if (ivar < dNTu->firstIndexed) im = -1;
    else {
     str = XmTextGetString(OneDHistMultW);
     if (GetIntText(OneDHistMultW, &im) == TEXT_READ_OK) {
        if (im > dNTu->maxMultiplicity) {
             DialogF(DF_WARN, OneDHistShellW, 1, 
 "Incorrect instance, above maximum Multiplicty.","Acknowledged");
             return;
        } else im--;
      } else {
        if ((strcmp(str,"All") == 0) || (strcmp(str,"ALL") == 0) ||
            (strcmp(str,"all") == 0)) im = -1;
        else if ((strcmp(str,"First") == 0) || (strcmp(str,"FIRST") == 0) ||
            (strcmp(str,"first") == 0)) im = 0;
        else if ((strcmp(str,"Second") == 0) || (strcmp(str,"SECOND") == 0) ||
            (strcmp(str,"second") == 0)) im = 1;
        else if ((strcmp(str,"Third") == 0) || (strcmp(str,"THIRD") == 0) ||
            (strcmp(str,"third") == 0)) im = 2;
        else {
             DialogF(DF_WARN, OneDHistShellW, 1, 
 "Incorrect instance, please use a number","Acknowledged");
             return;
        }
      }
    }     
/*
** We now read out the widget and define the histogram
*/
     str = XmTextGetString(OneDHistTitleW);
     if (GetIntTextWarn(OneDHistNumBinsW, &nBins,
                        "Number of Bins", TRUE) != TEXT_READ_OK) return;
     if (GetFloatTextWarn(OneDHistLowBinW, &dfrom,
                        "Low Bin Edge", TRUE) != TEXT_READ_OK) return;
     if (GetFloatTextWarn(OneDHistHighBinW, &dto,
                        "High Bin Edge", TRUE) != TEXT_READ_OK) return;
      from = (float) dfrom; to = (float) dto;
      /*
      ** At the beginning, the HistoList has a dummy item
      */
      if (FirstOneDHistogram) uid = 1;
      else if (newHisto) {
        XtSetArg (args[0], XmNitemCount, &uid);
        XtGetValues(OneDHistHistoListW, args, 1);
        uid++;
      } else uid = CurrentHistoUID; 
      if (ivarH == 0) 
          strcpy(x_label,"Multiplicity");
      else {
         var = dNTu->variables[ivar];
         if(strlen(var->name) < 17) strcpy(x_label,var->name);
         else {
            strncpy(x_label,var->name,16);
            strcpy(&x_label[16],"...");
         }
     }    
     idh = hs_create_1d_hist(uid, str,  "OneDHist", x_label, "Yield", 
                             nBins, from, to);
     XtFree(str);                        
     /*
     ** Store the idh, we need it for filling. Find the first free place on
     ** the list.
     */
    if (nTuBr->nHistoItems == nTuBr->sizeOfLists)
           mcfioC_ExtendBrowserAnalysis(nTuBr);
     nTuH1 = (nTuBroHs1D *) malloc(sizeof(nTuBroHs1D));
     index=0; 
     while (nTuBr->hsItemList[index] != NULL)  index++;
     nTuBr->hsItemList[index] =  (nTuBroHsGeneral *) nTuH1;
     nTuBr->nHistoItems++;
     nTuBr->nHisto1D++;
     nTuH1->id = idh;
     nTuH1->type = HS_1D_HISTOGRAM;
     nTuH1->varNumber = ivarH;
     nTuH1->subBlock = im;
     nTuH1->varIndices = NULL;
     if(dNTu->firstIndexed == -1) lastFixed = dNTu->numVariables;
           else lastFixed = dNTu->firstIndexed;
     if (ivarH != 0) { 
        var = dNTu->variables[ivar];
       if (var->numDim >= 1) {
          nTuH1->varIndices= (int *) malloc(sizeof(int) * var->numDim);
          ivk = nTuH1->varIndices;
          getVarIndexDialog(ivk, var->numDim, var->dimensions);
       } 
     }  
     if (nTuBr->data == NULL) mcfioC_createBrowserData(nTuBr);
     cDat = (char *) nTuBr->data;
     if (ivarH == 0) {
        cDat += dNTu->multOffset;
        nTuH1->lDat = (long *) cDat;
     } else {
          if (ivar < lastFixed) { 
            pp = ((long) nTuBr->data) +  dNTu->variables[ivar]->offset;
            nTuH1->lDat = (long *) pp;
          } else  nTuH1->lDat = NULL; 
               /* A specific subVariable (leaf), we'll compute the 
          		data pointer at filling time */
     }     		
     XtSetSensitive(OneDHistModifyW, True);
     XtSetSensitive(OneDHistDeleteW, True); 
     redisplay1DHistoList(); 
     FirstOneDHistogram = False; 
     hs_update();
}
Example #24
0
File: DragBS.c Project: att/uwin
/*
 * also called from DropSMgr.  Creates target list if not already
 * there.
 */
Cardinal
_XmTargetsToIndex(Widget shell, Atom *tlist, Cardinal numTargets)
{
    Display *dpy = XtDisplay(shell);
    XmDndTargetsTable targets;
    Cardinal i;
    Atom *atoms;

    DEBUGOUT(_LtDebug(__FILE__, shell,
		      "%s:_XmTargetsToIndex(%d) - %p 0x%x targets %p\n", 
		      __FILE__, __LINE__,
		      tlist,
		      numTargets,
		      tlist ? tlist[0] : 0
		      ));
#if 0
    /* For Netscape 4.5 PR1 binary compatibility testing.
       NS seems to be calling this routine with an invalid (huge) number
       of numTargets.  I just bail out of the whole routine for testing.
       -jac Sept 22, 1998 */
    return 0;
#endif

    if ((targets = get_targets_table(dpy)) == NULL)
    {
	_XmInitTargetsTable(dpy);

	targets = get_targets_table(dpy);
    }
    DEBUGOUT(_LtDebug(__FILE__, shell,
		      "%s:_XmTargetsToIndex(%d) - targets->num_entries %i\n", 
		      __FILE__, __LINE__,
		      targets->num_entries
		      ));

#if 1
    /* 28 Jul 1999
       Navigator is still calling this with a huge value for numTargets.
       So for now just do a check for this and bail.....
     */
    for (i = 0; i < targets->num_entries; i++)
    {
	if (numTargets == targets->entries[i].num_targets)
	{
	    break;
	}
    }
    if ((int)numTargets > 1000)
    {
    	return(0);
    }
#endif

    atoms = (Atom *)XtMalloc(numTargets * sizeof(Atom));
    for	(i = 0; i < numTargets; i++)
    {
    	atoms[i] = tlist[i];
    }

    qsort(atoms, numTargets, sizeof(Atom), acompare);

    /* maybe it's already there ? */
    for (i = 0; i < targets->num_entries; i++)
    {
	if (numTargets == targets->entries[i].num_targets &&
	    memcmp(atoms, targets->entries[i].targets,
		 sizeof(Atom) * numTargets) == 0)
	{
	    XtFree((char *)atoms);

	    return i;
	}
    }

    XGrabServer(dpy);

    if (!read_targets_table(dpy, targets))
    {
	XUngrabServer(dpy);

	_XmInitTargetsTable(dpy);

	XGrabServer(dpy);

	targets = get_targets_table(dpy);
    }

    /* maybe somebody added while we've been fooling around, but before
     * we said nuhuh with the grab */
    for (i = 0; i < targets->num_entries; i++)
    {
	if (numTargets == targets->entries[i].num_targets &&
	    memcmp(atoms, targets->entries[i].targets,
		 sizeof(Atom) * numTargets) == 0)
	{
	    XtFree((char *)atoms);

	    return i;
	}
    }

    /* nope.  add them */
    i = targets->num_entries;

    targets->num_entries++;
    targets->entries =
	(XmDndTargetsTableEntry)XtRealloc((char *)targets->entries,
					  sizeof(XmDndTargetsTableEntryRec) *
					  targets->num_entries);

    targets->entries[i].num_targets = numTargets;
    targets->entries[i].targets = atoms;

    write_targets_table(dpy, targets);

    XUngrabServer(dpy);

    XFlush(dpy);

    return i;
}
Example #25
0
static void CreateComboBoxes(Widget parent)
{
    Widget titleLabel, comboBox, list;
    XmString *valueXmstrings, *colorXmstrings;
    int numValueStrings, numColorStrings;
    XmString labelString, xmString;
    Arg args[20];
    int i, n;
    
    /* Create value compound strings */

    numValueStrings = XtNumber(comboValueStrings);
    valueXmstrings = (XmString *)XtMalloc(numValueStrings * sizeof(XmString*));
    for (i = 0; i < numValueStrings; i++) {
	valueXmstrings[i] = XmStringCreateLocalized(comboValueStrings[i]);
    }

    /* Create color compound strings */

    numColorStrings = XtNumber(colorStrings);
    colorXmstrings = (XmString *)XtMalloc(numColorStrings * sizeof(XmString*));
    for (i = 0; i < numColorStrings; i++) {
	colorXmstrings[i] = XmStringCreateLocalized(colorStrings[i]);
    }

    /* Create title label */

    labelString = XmStringCreateLocalized("ComboBox Widget");
    n = 0;
    XtSetArg(args[n], XmNlabelString, labelString); n++;
    titleLabel = XmCreateLabel(parent, "title", args, n);
    XtManageChild(titleLabel);
    XmStringFree(labelString);


    /*
     * Create an editable ComboBox containing the color strings.
     * Get the widget id of the drop down list, add some greek
     * letter names to it, and make more items visible.
     */

    n = 0;
    XtSetArg(args[n], DtNcomboBoxType, DtDROP_DOWN_COMBO_BOX); n++;
    XtSetArg(args[n], DtNitems, colorXmstrings); n++;
    XtSetArg(args[n], DtNitemCount, numColorStrings); n++;
    XtSetArg(args[n], DtNvisibleItemCount, 5); n++;
    XtSetArg(args[n], DtNcolumns, 10); n++;
    comboBox = DtCreateComboBox(parent, "comboBox1", args, n);
    XtManageChild(comboBox);

    list = XtNameToWidget(comboBox, "*List");
    XmListAddItems(list, valueXmstrings, 10, 0);
    XtVaSetValues(list, XmNvisibleItemCount, 10, NULL);


    /*
     * Create an editable ComboBox with no entries.
     * Get the widget id of the drop down list, add some greek
     * letter names to it and select the third item in the list.
     */

    n = 0;
    XtSetArg(args[n], DtNcomboBoxType, DtDROP_DOWN_COMBO_BOX); n++;
    XtSetArg(args[n], DtNorientation, DtLEFT); n++;
    XtSetArg(args[n], DtNcolumns, 10); n++;
    comboBox = DtCreateComboBox(parent, "comboBox2", args, n);
    XtManageChild(comboBox);

    list = XtNameToWidget(comboBox, "*List");        
    XmListAddItems(list, valueXmstrings, 7, 0);
    XtVaSetValues(list, XmNvisibleItemCount, 7, NULL);
    XtVaSetValues(comboBox, DtNselectedPosition, 3, NULL);


    /*
     * Create a non-editable ComboBox containing some greek letter names.
     * Position the arrow on the left.
     * Select the 'gamma' item in the list.
     */

    n = 0;
    XtSetArg(args[n], DtNorientation, DtLEFT); n++;
    XtSetArg(args[n], DtNitems, valueXmstrings); n++;
    XtSetArg(args[n], DtNitemCount, numValueStrings); n++;
    XtSetArg(args[n], DtNvisibleItemCount, 8); n++;
    comboBox = DtCreateComboBox(parent, "comboBox3", args, n);
    XtManageChild(comboBox);

    xmString = XmStringCreateLocalized("gamma");
    XtVaSetValues(comboBox, DtNselectedItem, xmString, NULL);
    XmStringFree(xmString);


    /*
     * Create a non-editable ComboBox with no entries.
     * Position the arrow on the right.
     * Add the greek letter names to the list and select the fourth item. 
     */

    n = 0;
    XtSetArg(args[n], DtNorientation, DtRIGHT); n++;
    XtSetArg(args[n], DtNvisibleItemCount, 8); n++;
    comboBox = DtCreateComboBox(parent, "comboBox4", args, n);
    XtManageChild(comboBox);

    for (i = 0; i < numValueStrings; i++) {
	DtComboBoxAddItem(comboBox, valueXmstrings[i], 0, True);
    }
    XtVaSetValues(comboBox, DtNselectedPosition, 4, NULL);


    /*
     * Free value and color strings, ComboBox has taken a copy.
     */

    for (i = 0; i < numValueStrings; i++) {
	XmStringFree(valueXmstrings[i]);
    }
    XtFree((char*)valueXmstrings);

    for (i = 0; i < numColorStrings; i++) {
	XmStringFree(colorXmstrings[i]);
    }
    XtFree((char*)colorXmstrings);
}
Example #26
0
File: DragBS.c Project: att/uwin
/*
 * if the ATOM_PAIRS didn't exist, put them on the drag window
 */
static void
write_atom_pairs(Display *display)
{
    char pairs[1000];
    char names[1000];
    XmDndAtomPairs pair_rec;
    XmDndBufMgrRec bmgr;
    XmDndAtomPair pair;
    Atom pa;
    int i;
    Window win;

    DEBUGOUT(_LtDebug0(__FILE__, NULL, "%s:write_atom_pairs(%d)\n",
		      __FILE__, __LINE__));

    pair_rec.byte_order = _XmByteOrder();
    pair_rec.protocol_version = DND_PROTOCOL_VERSION;
    pair_rec.num_pairs = XtNumber(motifAtoms);

    bmgr.atoms = pairs;
    bmgr.atom_ptr = pairs;
    bmgr.atom_start = NULL;
    bmgr.atom_size = 0;
    bmgr.atom_avail = 1000;
    bmgr.names = names;
    bmgr.name_ptr = names;
    bmgr.name_start = NULL;
    bmgr.name_size = 0;
    bmgr.name_avail = 1000;

    _XmWriteDragBuffer(&bmgr, False, (char *)&pair_rec, sizeof(XmDndAtomPairs));

    for (i = 0; i < XtNumber(motifAtoms); i++)
    {
	pair.atom = XmInternAtom(display, motifAtoms[i], False);

	pair.namelen = strlen(motifAtoms[i]) + 1;

	_XmWriteDragBuffer(&bmgr, True, motifAtoms[i], pair.namelen);

	_XmWriteDragBuffer(&bmgr, False, (char *)&pair, sizeof(XmDndAtomPair));

    }

    ((XmDndAtomPairs *) (bmgr.atoms))->data_size = bmgr.atom_size;

    pa = XmInternAtom(display, _XA_MOTIF_DRAG_ATOM_PAIRS, False);

    win = get_drag_window(display);

    begin_protection(display, win);

    XChangeProperty(display, win, pa, pa, 8, PropModeReplace,
		    (unsigned char *)bmgr.atoms, bmgr.atom_size);

    if (bmgr.atoms != bmgr.atom_ptr)
    {
	XtFree(bmgr.atoms);
    }

    if (bmgr.name_size)
    {
	XChangeProperty(display, win, pa, pa, 8, PropModeAppend,
			(unsigned char *)bmgr.names, bmgr.name_size);

	if (bmgr.names != bmgr.name_ptr)
	{
	    XtFree(bmgr.names);
	}
    }

    end_protection(display);

    if (bad_window)
    {
	_XmWarning((Widget)XmGetXmDisplay(display),
		   "Bad window writing ATOM_PAIRS property on DRAG_WINDOW.");
    }
}
Example #27
0
DBInt UIDataHeaderForm(DBObjData *data) {
    char *text;
    DBInt i, edit;
    DBUnsigned var;
    static DBInt dataType, save, changed[10];
    static Widget dShell = NULL;
    static Widget nameTextF, subjectTextF, geoDomTextF, versionTextF, lastModL, ownerL;
    static Widget citRefText, citInstTextF, srcInstTextF, srcPersTextF, commentText;
    static Widget typeMenu;

    if (dShell == NULL) {
        XmString string, select;
        Widget mainForm, label, button, separator;

        var = 0;
        dShell = UIDialogForm((char *) "Data Header Information");
        mainForm = UIDialogFormGetMainForm(dShell);
        select = XmStringCreate((char *) "Select", UICharSetBold);
        string = XmStringCreate((char *) "Name:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormNameLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_FORM,
                                        XmNtopOffset, 10,
                                        XmNrightAttachment, XmATTACH_POSITION,
                                        XmNrightPosition, 25,
                                        XmNrightOffset, 10,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        nameTextF = XtVaCreateManagedWidget("UIDataHeaderFormNameText", xmTextFieldWidgetClass, mainForm,
                                            XmNtopAttachment, XmATTACH_FORM,
                                            XmNtopOffset, 10,
                                            XmNleftAttachment, XmATTACH_WIDGET,
                                            XmNleftWidget, label,
                                            XmNleftOffset, 5,
                                            XmNmaxLength, DBDataNameLen - 1,
                                            XmNcolumns, DBDataNameLen - 1,
                                            NULL);
        XtAddCallback(nameTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK, changed + var++);
        typeMenu = XmCreatePulldownMenu(mainForm, (char *) "UIDataHeaderFormTypeMenu", NULL, 0);
        for (i = 0; i < (int) (sizeof(_UIDataTypeList) / sizeof(UIButtonList)); ++i) {
            string = XmStringCreate(DBDataTypeString(_UIDataTypeList[i].ID), UICharSetNormal);
            _UIDataTypeList[i].Button = XtVaCreateManagedWidget("UIDataHeaderFormTypeButton", xmPushButtonGadgetClass,
                                                                typeMenu,
                                                                XmNuserData, _UIDataTypeList[i].ID,
                                                                XmNlabelString, string,
                                                                NULL);
            XmStringFree(string);
            XtAddCallback(_UIDataTypeList[i].Button, XmNactivateCallback, (XtCallbackProc) _UIDataHeaderFormButtonCBK,
                          &dataType);
        }
        string = XmStringCreate((char *) "Data Type:", UICharSetBold);
        typeMenu = XtVaCreateManagedWidget("UIDataHeaderFormTypeMenu", xmRowColumnWidgetClass, mainForm,
                                           XmNtopAttachment, XmATTACH_WIDGET,
                                           XmNtopWidget, nameTextF,
                                           XmNtopOffset, 2,
                                           XmNrightAttachment, XmATTACH_FORM,
                                           XmNrightOffset, 10,
                                           XmNsubMenuId, typeMenu,
                                           XmNlabelString, string,
                                           XmNrowColumnType, XmMENU_OPTION,
                                           XmNtraversalOn, false,
                                           NULL);
        XmStringFree(string);
        string = XmStringCreate((char *) "Subject:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormSubjectLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, nameTextF,
                                        XmNtopOffset, 10,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        subjectTextF = XtVaCreateManagedWidget("UIDataHeaderFormSubjectField", xmTextFieldWidgetClass, mainForm,
                                               XmNtopAttachment, XmATTACH_WIDGET,
                                               XmNtopWidget, nameTextF,
                                               XmNtopOffset, 10,
                                               XmNleftAttachment, XmATTACH_WIDGET,
                                               XmNleftWidget, label,
                                               XmNleftOffset, 5,
                                               XmNmaxLength, DBDataSubjectLen - 1,
                                               XmNcolumns, DBDataSubjectLen - 1,
                                               NULL);
        XtAddCallback(subjectTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        button = XtVaCreateManagedWidget("UIDataHeaderFormSubjectSelectButton", xmPushButtonWidgetClass, mainForm,
                                         XmNtopAttachment, XmATTACH_WIDGET,
                                         XmNtopWidget, nameTextF,
                                         XmNtopOffset, 10,
                                         XmNleftAttachment, XmATTACH_WIDGET,
                                         XmNleftWidget, subjectTextF,
                                         XmNleftOffset, 5,
                                         XmNrightAttachment, XmATTACH_WIDGET,
                                         XmNrightWidget, typeMenu,
                                         XmNrightOffset, 20,
                                         XmNlabelString, select,
                                         XmNtraversalOn, false,
                                         XmNuserData, (XtArgVal) UIDatasetSubject,
                                         NULL);
        XtAddCallback(button, XmNactivateCallback, (XtCallbackProc) _UIDataHeaderButtonCBK, subjectTextF);


        string = XmStringCreate((char *) "Geograhic Domain:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormGeoDomainLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, subjectTextF,
                                        XmNtopOffset, 10,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        geoDomTextF = XtVaCreateManagedWidget("UIDataHeaderFormGeoField", xmTextFieldWidgetClass, mainForm,
                                              XmNtopAttachment, XmATTACH_WIDGET,
                                              XmNtopWidget, subjectTextF,
                                              XmNtopOffset, 10,
                                              XmNleftAttachment, XmATTACH_WIDGET,
                                              XmNleftWidget, label,
                                              XmNleftOffset, 5,
                                              XmNmaxLength, DBDataSubjectLen - 1,
                                              XmNcolumns, DBDataSubjectLen - 1,
                                              NULL);
        XtAddCallback(geoDomTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        button = XtVaCreateManagedWidget("UIDataHeaderFormGeoDomainSelectButton", xmPushButtonWidgetClass, mainForm,
                                         XmNtopAttachment, XmATTACH_WIDGET,
                                         XmNtopWidget, subjectTextF,
                                         XmNtopOffset, 10,
                                         XmNleftAttachment, XmATTACH_WIDGET,
                                         XmNleftWidget, geoDomTextF,
                                         XmNleftOffset, 5,
                                         XmNrightAttachment, XmATTACH_WIDGET,
                                         XmNrightWidget, typeMenu,
                                         XmNrightOffset, 20,
                                         XmNlabelString, select,
                                         XmNuserData, (XtArgVal) UIDatasetGeoDomain,
                                         XmNtraversalOn, false,
                                         NULL);
        XtAddCallback(button, XmNactivateCallback, (XtCallbackProc) _UIDataHeaderButtonCBK, geoDomTextF);


        versionTextF = XtVaCreateManagedWidget("UIDataHeaderFormVersionText", xmTextFieldWidgetClass, mainForm,
                                               XmNtopAttachment, XmATTACH_WIDGET,
                                               XmNtopWidget, subjectTextF,
                                               XmNtopOffset, 5,
                                               XmNrightAttachment, XmATTACH_FORM,
                                               XmNrightOffset, 10,
                                               XmNcolumns, DBDataVersionLen - 1,
                                               NULL);
        XtAddCallback(versionTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        string = XmStringCreate((char *) "Version:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormVersion", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, subjectTextF,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, versionTextF,
                                        XmNrightOffset, 5,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        separator = XtVaCreateManagedWidget("UIDataHeaderFormSeparator", xmSeparatorWidgetClass, mainForm,
                                            XmNtopAttachment, XmATTACH_WIDGET,
                                            XmNtopWidget, geoDomTextF,
                                            XmNtopOffset, 5,
                                            XmNleftAttachment, XmATTACH_FORM,
                                            XmNleftOffset, 20,
                                            XmNrightAttachment, XmATTACH_FORM,
                                            XmNrightOffset, 20,
                                            NULL);
        string = XmStringCreate((char *) "Citation Reference:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormCitRefLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, separator,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        citRefText = XtVaCreateManagedWidget("UIDataHeaderFormCitRefText", xmTextWidgetClass, mainForm,
                                             XmNtopAttachment, XmATTACH_WIDGET,
                                             XmNtopWidget, separator,
                                             XmNtopOffset, 5,
                                             XmNleftAttachment, XmATTACH_WIDGET,
                                             XmNleftWidget, label,
                                             XmNleftOffset, 5,
                                             XmNmaxLength, DBDataCitationRefLen - 1,
                                             XmNrows, DBDataCitationRefLen / DBDataNameLen,
                                             XmNcolumns, DBDataNameLen - 1,
                                             XmNeditMode, XmMULTI_LINE_EDIT,
                                             XmNwordWrap, true,
                                             NULL);
        XtAddCallback(citRefText, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextCBK, changed + var++);
        string = XmStringCreate((char *) "Citation Institute:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormInstRefLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, citRefText,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNalignment, XmALIGNMENT_END,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        citInstTextF = XtVaCreateManagedWidget("UIDataHeaderFormCitInstText", xmTextFieldWidgetClass, mainForm,
                                               XmNtopAttachment, XmATTACH_WIDGET,
                                               XmNtopWidget, citRefText,
                                               XmNtopOffset, 5,
                                               XmNleftAttachment, XmATTACH_WIDGET,
                                               XmNleftWidget, label,
                                               XmNleftOffset, 5,
                                               XmNmaxLength, DBDataCitationInstLen - 1,
                                               XmNcolumns, DBDataNameLen - 1,
                                               NULL);
        XtAddCallback(citInstTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        string = XmStringCreate((char *) "Source Institue:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormSourceInstLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, citInstTextF,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        srcInstTextF = XtVaCreateManagedWidget("UIDataHeaderFormSourceInstText", xmTextFieldWidgetClass, mainForm,
                                               XmNtopAttachment, XmATTACH_WIDGET,
                                               XmNtopWidget, citInstTextF,
                                               XmNtopOffset, 5,
                                               XmNleftAttachment, XmATTACH_WIDGET,
                                               XmNleftWidget, label,
                                               XmNleftOffset, 5,
                                               XmNmaxLength, DBDataSourceInstLen - 1,
                                               XmNcolumns, DBDataNameLen - 1,
                                               NULL);
        XtAddCallback(srcInstTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        string = XmStringCreate((char *) "Source Person:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormSourcePersonLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, srcInstTextF,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        srcPersTextF = XtVaCreateManagedWidget("UIDataHeaderFormSourcePersText", xmTextFieldWidgetClass, mainForm,
                                               XmNtopAttachment, XmATTACH_WIDGET,
                                               XmNtopWidget, srcInstTextF,
                                               XmNtopOffset, 5,
                                               XmNleftAttachment, XmATTACH_WIDGET,
                                               XmNleftWidget, label,
                                               XmNleftOffset, 5,
                                               XmNmaxLength, DBDataSourcePersonLen - 1,
                                               XmNcolumns, DBDataSourcePersonLen - 1,
                                               NULL);
        XtAddCallback(srcPersTextF, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextFieldCBK,
                      changed + var++);
        string = XmStringCreate((char *) "Last Modification:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormVersion", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, srcInstTextF,
                                        XmNtopOffset, 5,
                                        XmNleftAttachment, XmATTACH_WIDGET,
                                        XmNleftWidget, srcPersTextF,
                                        XmNleftOffset, 10,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        string = XmStringCreate((char *) " ", UICharSetNormal);
        lastModL = XtVaCreateManagedWidget("UIDataHeaderFormVersion", xmLabelGadgetClass, mainForm,
                                           XmNtopAttachment, XmATTACH_WIDGET,
                                           XmNtopWidget, srcInstTextF,
                                           XmNtopOffset, 5,
                                           XmNleftAttachment, XmATTACH_WIDGET,
                                           XmNleftWidget, label,
                                           XmNleftOffset, 5,
                                           XmNwidth, 100,
                                           XmNrecomputeSize, false,
                                           XmNlabelString, string,
                                           NULL);
        XmStringFree(string);
        string = XmStringCreate((char *) "Last Modification:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormVersion", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, srcInstTextF,
                                        XmNtopOffset, 5,
                                        XmNleftAttachment, XmATTACH_WIDGET,
                                        XmNleftWidget, srcPersTextF,
                                        XmNleftOffset, 10,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        string = XmStringCreate((char *) " ", UICharSetNormal);
        lastModL = XtVaCreateManagedWidget("UIDataHeaderFormVersion", xmLabelGadgetClass, mainForm,
                                           XmNtopAttachment, XmATTACH_WIDGET,
                                           XmNtopWidget, srcInstTextF,
                                           XmNtopOffset, 5,
                                           XmNleftAttachment, XmATTACH_WIDGET,
                                           XmNleftWidget, label,
                                           XmNleftOffset, 5,
                                           XmNwidth, 100,
                                           XmNrecomputeSize, false,
                                           XmNlabelString, string,
                                           NULL);
        XmStringFree(string);
        string = XmStringCreate((char *) "Owner:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormVersion", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, lastModL,
                                        XmNtopOffset, 5,
                                        XmNleftAttachment, XmATTACH_WIDGET,
                                        XmNleftWidget, srcPersTextF,
                                        XmNleftOffset, 10,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        string = XmStringCreate((char *) " ", UICharSetNormal);
        ownerL = XtVaCreateManagedWidget("UIDataHeaderFormVersion", xmLabelGadgetClass, mainForm,
                                           XmNtopAttachment, XmATTACH_WIDGET,
                                           XmNtopWidget, lastModL,
                                           XmNtopOffset, 5,
                                           XmNleftAttachment, XmATTACH_WIDGET,
                                           XmNleftWidget, label,
                                           XmNleftOffset, 5,
                                           XmNwidth, 100,
                                           XmNrecomputeSize, false,
                                           XmNlabelString, string,
                                           NULL);
        XmStringFree(string);
        string = XmStringCreate((char *) "Comment:", UICharSetBold);
        label = XtVaCreateManagedWidget("UIDataHeaderFormCommentLabel", xmLabelWidgetClass, mainForm,
                                        XmNtopAttachment, XmATTACH_WIDGET,
                                        XmNtopWidget, ownerL,
                                        XmNtopOffset, 5,
                                        XmNrightAttachment, XmATTACH_WIDGET,
                                        XmNrightWidget, nameTextF,
                                        XmNrightOffset, 5,
                                        XmNlabelString, string,
                                        NULL);
        XmStringFree(string);
        commentText = XtVaCreateManagedWidget("UIDataHeaderFormCommentText", xmTextWidgetClass, mainForm,
                                              XmNtopAttachment, XmATTACH_WIDGET,
                                              XmNtopWidget, ownerL,
                                              XmNtopOffset, 5,
                                              XmNleftAttachment, XmATTACH_WIDGET,
                                              XmNleftWidget, label,
                                              XmNleftOffset, 5,
                                              XmNbottomAttachment, XmATTACH_FORM,
                                              XmNtopOffset, 10,
                                              XmNmaxLength, DBDataCommentLen - 1,
                                              XmNrows, DBDataCommentLen / DBDataNameLen,
                                              XmNcolumns, DBDataNameLen - 1,
                                              XmNeditMode, XmMULTI_LINE_EDIT,
                                              XmNwordWrap, true,
                                              NULL);
        XtAddCallback(commentText, XmNvalueChangedCallback, (XtCallbackProc) _UIDataHeaderTextCBK, changed + var++);
        XtAddCallback(UIDialogFormGetOkButton(dShell), XmNactivateCallback, (XtCallbackProc) UIAuxSetBooleanTrueCBK,
                      &save);
        XmStringFree(select);
    }

    edit = true;
    for (i = sizeof(_UIDataTypeList) / sizeof(UIButtonList) - 1; i >= 0; --i)
        if ((_UIDataTypeList[i].ID & data->Type()) == data->Type()) {
            XtSetSensitive(_UIDataTypeList[i].Button, true);
            XtVaSetValues(typeMenu, XmNmenuHistory, _UIDataTypeList[i].Button, NULL);
            dataType = _UIDataTypeList[i].ID;
        }
        else XtSetSensitive(_UIDataTypeList[i].Button, false);

    XtVaSetValues(nameTextF, XmNuserData, data->Name(), NULL);
    XmTextFieldSetString(nameTextF, data->Name());
    XmTextFieldSetEditable(nameTextF, edit);

    XtVaSetValues(subjectTextF, XmNuserData, data->Document(DBDocSubject), NULL);
    XmTextFieldSetString(subjectTextF, data->Document(DBDocSubject));
    XmTextFieldSetEditable(subjectTextF, edit);

    XtVaSetValues(geoDomTextF, XmNuserData, data->Document(DBDocGeoDomain), NULL);
    XmTextFieldSetString(geoDomTextF, data->Document(DBDocGeoDomain));
    XmTextFieldSetEditable(geoDomTextF, edit);

    XtVaSetValues(versionTextF, XmNuserData, data->Document(DBDocVersion), NULL);
    XmTextFieldSetString(versionTextF, data->Document(DBDocVersion));
    XmTextFieldSetEditable(versionTextF, edit);

    XtVaSetValues(citRefText, XmNuserData, data->Document(DBDocCitationRef), NULL);
    XmTextSetString(citRefText, data->Document(DBDocCitationRef));
    XmTextSetEditable(citRefText, edit);

    XtVaSetValues(citInstTextF, XmNuserData, data->Document(DBDocCitationInst), NULL);
    XmTextFieldSetString(citInstTextF, data->Document(DBDocCitationInst));
    XmTextFieldSetEditable(citInstTextF, edit);

    XtVaSetValues(srcInstTextF, XmNuserData, data->Document(DBDocSourceInst), NULL);
    XmTextFieldSetString(srcInstTextF, data->Document(DBDocSourceInst));
    XmTextFieldSetEditable(srcInstTextF, edit);

    XtVaSetValues(srcPersTextF, XmNuserData, data->Document(DBDocSourcePerson), NULL);
    XmTextFieldSetString(srcPersTextF, data->Document(DBDocSourcePerson));
    XmTextFieldSetEditable(srcPersTextF, edit);

    XtVaSetValues(commentText, XmNuserData, data->Document(DBDocComment), NULL);
    XmTextSetString(commentText, data->Document(DBDocComment));
    XmTextSetEditable(commentText, edit);

    if (data->LastModification().Year() != DBDefaultMissingIntVal)
        UIAuxSetLabelString (lastModL, data->LastModification().Get());
    else
        UIAuxSetLabelString (lastModL, (char *) " ");
    if ((data->Document(DBDocOwnerPerson) != (char *) NULL) && (strlen(data->Document(DBDocOwnerPerson)) > 0))
        UIAuxSetLabelString (ownerL, data->Document(DBDocOwnerPerson));
    else
        UIAuxSetLabelString (ownerL, (char  *) " ");
    save = false;
    XmProcessTraversal(nameTextF, XmTRAVERSE_CURRENT);
    UIDialogFormPopup(dShell);
    for (i = 0; i < (int) (sizeof(changed) / sizeof(int)); ++i) changed[i] = false;
    while (UILoop()) {
        var = 0;
        text = XmTextFieldGetString(nameTextF);
        if (strlen(text) == 0)
            XtSetSensitive(UIDialogFormGetOkButton(dShell), false);
        else {
            for (i = 0; i < (int) (sizeof(changed) / sizeof(int)); ++i)
                var = changed[i] ? var + 1 : var;
            XtSetSensitive(UIDialogFormGetOkButton(dShell), var > 0);
        }
        XtFree(text);
    }
    UIDialogFormPopdown(dShell);

    if (save) {
        text = XmTextFieldGetString(nameTextF);
        data->Name(text);
        XtFree(text);
        text = XmTextFieldGetString(subjectTextF);
        data->Document(DBDocSubject, text);
        XtFree(text);
        text = XmTextFieldGetString(geoDomTextF);
        data->Document(DBDocGeoDomain, text);
        XtFree(text);
        text = XmTextFieldGetString(versionTextF);
        data->Document(DBDocVersion, text);
        XtFree(text);
        text = XmTextGetString(citRefText);
        data->Document(DBDocCitationRef, text);
        XtFree(text);
        text = XmTextFieldGetString(citInstTextF);
        data->Document(DBDocCitationInst, text);
        XtFree(text);
        text = XmTextFieldGetString(srcInstTextF);
        data->Document(DBDocSourceInst, text);
        XtFree(text);
        text = XmTextFieldGetString(srcPersTextF);
        data->Document(DBDocSourcePerson, text);
        XtFree(text);
        text = XmTextGetString(commentText);
        data->Document(DBDocComment, text);
        XtFree(text);
        if (data->Type() != dataType) data->Type(dataType);
        return (true);
    }
    else return (false);
}
Example #28
0
File: DragBS.c Project: att/uwin
/*
 * write the atoms table out to the drag window
 */
static void
write_atoms_table(Display *display, XmDndAtomsTable tbl)
{
    char atoms[1000];
    XmDndAtoms atoms_rec;
    XmDndBufMgrRec bmgr;
    Atom pa;
    int i;
    Window win;

    DEBUGOUT(_LtDebug0(__FILE__, NULL, "%s:write_atoms_table(%d)\n",
		      __FILE__, __LINE__));

    if (tbl == NULL)
    {
	_XmWarning((Widget)XmGetXmDisplay(display),
		   "No DRAG_ATOMS to write to DRAG_WINDOW.");

	return;
    }

    atoms_rec.byte_order = _XmByteOrder();
    atoms_rec.protocol_version = DND_PROTOCOL_VERSION;
    atoms_rec.num_atoms = tbl->num_entries;

    bmgr.atoms = atoms;
    bmgr.atom_ptr = atoms;
    bmgr.atom_start = NULL;
    bmgr.atom_size = 0;
    bmgr.atom_avail = 1000;

    _XmWriteDragBuffer(&bmgr, False, (char *)&atoms_rec, sizeof(XmDndAtoms));

    for (i = 0; i < tbl->num_entries; i++)
    {
	_XmWriteDragBuffer(&bmgr, False, (char *)&tbl->entries[i],
			   sizeof(XmDndAtomsTableEntryRec));

    }

    ((XmDndAtoms *) (bmgr.atoms))->data_size = bmgr.atom_size;

    pa = XmInternAtom(display, _XA_MOTIF_DRAG_ATOMS, False);

    win = get_drag_window(display);

    begin_protection(display, win);

    XChangeProperty(display, win, pa, pa, 8, PropModeReplace,
		    (unsigned char *)bmgr.atoms, bmgr.atom_size);

    if (bmgr.atoms != bmgr.atom_ptr)
    {
	XtFree(bmgr.atoms);
    }

    end_protection(display);

    if (bad_window)
    {
	_XmWarning((Widget)XmGetXmDisplay(display),
		   "Bad window writing DRAG_ATOMS on DRAG_WINDOW.");
    }
}
Example #29
0
void iupdrvTextConvertPosToLinCol(Ihandle* ih, int pos, int *lin, int *col)
{
  char *str = XmTextGetString(ih->handle);
  motTextGetLinColFromPosition(str, pos, lin, col);
  XtFree(str);
}
Example #30
0
// Return true iff S1 is a prefix of S2
static bool is_prefix(const MString& m1, const MString& m2)
{
    XmString s1 = m1.xmstring();
    XmString s2 = m2.xmstring();

    XmStringContext c1;
    XmStringContext c2;

    XmStringInitContext(&c1, s1);
    XmStringInitContext(&c2, s2);

    XmStringComponentType t1 = XmSTRING_COMPONENT_UNKNOWN;
    XmStringComponentType t2 = XmSTRING_COMPONENT_UNKNOWN;

    while (t1 != XmSTRING_COMPONENT_END && t2 != XmSTRING_COMPONENT_END)
    {
	char *s_text1            = 0;
	XmStringCharSet s_cs1    = 0;
	XmStringDirection d1     = XmSTRING_DIRECTION_DEFAULT;
	XmStringComponentType u1 = XmSTRING_COMPONENT_UNKNOWN;
	unsigned short ul1       = 0;
	unsigned char *s_uv1     = 0;
	
	t1 = XmStringGetNextComponent(c1, &s_text1, &s_cs1, &d1, 
				      &u1, &ul1, &s_uv1);

	char *s_text2            = 0;
	XmStringCharSet s_cs2    = 0;
	XmStringDirection d2     = XmSTRING_DIRECTION_DEFAULT;
	XmStringComponentType u2 = XmSTRING_COMPONENT_UNKNOWN;
	unsigned short ul2       = 0;
	unsigned char *s_uv2     = 0;

	t2 = XmStringGetNextComponent(c2, &s_text2, &s_cs2, &d2,
				      &u2, &ul2, &s_uv2);

	// Upon EOF in LessTif 0.82, XmStringGetNextComponent()
	// returns XmSTRING_COMPONENT_UNKNOWN instead of
	// XmSTRING_COMPONENT_END.  Work around this.
	if (t1 == XmSTRING_COMPONENT_UNKNOWN && s_uv1 == 0)
	    t1 = XmSTRING_COMPONENT_END;
	if (t2 == XmSTRING_COMPONENT_UNKNOWN && s_uv2 == 0)
	    t2 = XmSTRING_COMPONENT_END;

	// Place string values in strings
	string text1(s_text1 == 0 ? "" : s_text1);
	string text2(s_text2 == 0 ? "" : s_text2);
	string cs1(s_cs1 == 0 ? "" : s_cs1);
	string cs2(s_cs2 == 0 ? "" : s_cs2);
	string uv1;
	string uv2;
	if (s_uv1 != 0)
	    uv1 = string((char *)s_uv1, ul1);
	if (s_uv2 != 0)
	    uv2 = string((char *)s_uv2, ul2);

	// Free unused memory
	XtFree(s_text1);
	XtFree(s_text2);
	XtFree(s_cs1);
	XtFree(s_cs2);
	XtFree((char *)s_uv1);
	XtFree((char *)s_uv2);

	if (t1 != t2)
	{
	    goto done;		// Differing tags
	}

	switch (t1)
	{
	case XmSTRING_COMPONENT_CHARSET:
	{
	    if (cs1.empty())	// In LessTif 0.82, XmStringGetNextComponent()
		cs1 = text1;	// swaps CS and TEXT.  Work around this.
	    if (cs2.empty())
		cs2 = text2;

	    if (cs1 != cs2)
		goto done;	// Differing character sets
	    break;
	}

	case XmSTRING_COMPONENT_TEXT:
#if XmVersion >= 1002
	case XmSTRING_COMPONENT_LOCALE_TEXT:
#endif
#if XmVersion >= 2000
	case XmSTRING_COMPONENT_WIDECHAR_TEXT:
#endif
	{
	    if (text1.empty())	// In LessTif 0.82, XmStringGetNextComponent()
		text1 = cs1;	// swaps CS and TEXT.  Work around this.
	    if (text2.empty())
		text2 = cs2;

	    if (!text2.contains(text1, 0))
		goto done;
	    XmStringComponentType next2 = XmStringPeekNextComponent(c2);

	    // In LessTif 0.82, XmStringPeekNextComponent() returns
	    // XmSTRING_COMPONENT_UNKNOWN instead of
	    // XmSTRING_COMPONENT_END.  Work around this.
	    if (next2 != XmSTRING_COMPONENT_END && 
		next2 != XmSTRING_COMPONENT_UNKNOWN)
		goto done;
	    break;
	}

	case XmSTRING_COMPONENT_DIRECTION:
	{
	    if (d1 != d2)
		goto done;
	    break;
	}

	case XmSTRING_COMPONENT_SEPARATOR:
	case XmSTRING_COMPONENT_END:
	{
	    // These are the same by definition
	    break;
	}

	case XmSTRING_COMPONENT_UNKNOWN:
	{
	    if (uv1 != uv2)
		goto done;	// Differing unknown tags
	    break;
	}

	default:
	{
	    break;		// Skip everything else
	}
	}
    }
 done:

    XmStringFreeContext(c2);
    XmStringFreeContext(c1);

    return t1 == XmSTRING_COMPONENT_END;
}