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); } }
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); }
void iupdrvTextConvertLinColToPos(Ihandle* ih, int lin, int col, int *pos) { char* str = XmTextGetString(ih->handle); *pos = motTextSetLinColToPosition(str, lin, col); XtFree(str); }
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 ); }
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); }
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); }
/************************************************************************ * 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); }
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) ; }
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 */
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); }
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); }
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 ; } } } } }
/*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; }
/****************************************************************************** * 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; }
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; }
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); } }
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; }
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 ); }
/************************************************************************ * 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); }
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 */
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(); }
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(); }
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(); }
/* * 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; }
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); }
/* * 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."); } }
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); }
/* * 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."); } }
void iupdrvTextConvertPosToLinCol(Ihandle* ih, int pos, int *lin, int *col) { char *str = XmTextGetString(ih->handle); motTextGetLinColFromPosition(str, pos, lin, col); XtFree(str); }
// 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; }