do{ int nn , iq ;                                                                \
         if( (name)->num == (name)->nall ){                                            \
            nn = (name)->nall = 1.1*(name)->nall + INC_RSA ;                            \
            (name)->rsarr = realloc( (name)->rsarr,sizeof(RENDER_state *)*nn );          \
            for( iq=(name)->num ; iq < (name)->nall ; iq++ ) (name)->rsarr[iq] = NULL ; } \
         nn = (name)->num ; ((name)->num)++ ;                                             \
         (name)->rsarr[nn] = (imm) ; break ; } while(0)

if( strcmp(left,#nnn) == 0 ){         \
                           rs -> nnn = strtod(right,NULL) ;  \
                           continue ;                        \
                       }

if( strncmp(left,#nnn,strlen(#nnn)) == 0 ){                           \
      char * srb = strstr(left,"[") ;                                    \
      if( srb != NULL ){                                                 \
         int iii = strtol(srb+1,NULL,10) ;                               \
         if( iii >= 0 && iii < mmm ) rs->nnn[iii] = strtod(right,NULL) ; \
      }                                                                  \
      continue ;                                                         \
   }

if( strcmp(left,#nnn) == 0 ){           \
                        rs -> nnn = strtol(right,NULL,10) ;  \
                        continue ;                           \
                     }

do{ if( xhair_flag && dset!=NULL &&                                   \
          ! EQUIV_DATAXES(dset->daxes,im3d->wod_daxes) ){               \
        MCW_set_bbox( xhair_bbox , 0 ) ; xhair_flag = 0 ;               \
        (void) MCW_popup_message( xhair_bbox->wrowcol ,                 \
                                     "Can't overlay AFNI crosshairs\n"  \
                                     "because dataset grid and AFNI\n"  \
                                     "viewing grid don't coincide."   , \
                                  MCW_USER_KILL | MCW_TIMER_KILL ) ;    \
        XBell(dc->display,100) ; return ;                               \
     } } while(0)

( im3d->vinfo->i1             != xhair_ixold || \
                             im3d->vinfo->j2             != xhair_jyold || \
                             im3d->vinfo->k3             != xhair_kzold || \
                             im3d->vinfo->xhairs_orimask != xhair_omold   )

do{ int nn ;                                                         \
         if( (name) != NULL ){                                             \
            for( nn=0 ; nn < (name)->num ; nn++ ) free((name)->rsarr[nn]) ; \
            free((name)->rsarr); free((name)); (name) = NULL; } break; } while(0)

((func_dset != NULL && func_see_overlay) ||          \
                      func_see_ttatlas || (xhair_flag && xhair_ovc > 0) )

do{ for( ; fptr[0] != '\n' && fptr[0] != '\0' ; fptr++ ) ;    \
      if( fptr[0] == '\0' ) goto Finished ;                              \
      fptr++ ; } while(0)

do{ int sel_height ;  XtPointer sel_ptr ;                  \
         if( wfunc_thr_scale != NULL ){                         \
           XtVaGetValues( wfunc_thr_scale ,                     \
                             XmNuserData , &sel_ptr , NULL ) ;  \
           sel_height = (int) sel_ptr ;                         \
           XtVaSetValues( wfunc_thr_scale ,                     \
                             XmNheight , sel_height , NULL ) ;  \
           XtManageChild(wfunc_thr_scale) ;                     \
       } } while(0)

do{ if( (name) != NULL ){ \
            free((name)->rsarr); free((name)); (name) = NULL; } break; } while(0)

do{ FREEIM(grim) ; FREEIM(opim) ;                   \
      FREEIM(grim_showthru); FREEIM(opim_showthru) ; } while(0) ;

do{ GETSTR ; if(ISTARRED(str)) goto SkipSection ;    \
      strcpy(left,str) ;                               \
      GETSTR ; if(ISTARRED(str)) goto SkipSection ;    \
      strcpy(middle,str) ;                             \
      GETSTR ; if(ISTARRED(str)) goto SkipSection ;    \
      strcpy(right,str) ; } while(0)

do{ int nu=0,qq;                                                        \
      if( fptr-fbuf >= nbuf || fptr[0] == '\0' ) goto Finished ;          \
      str[0]='\0'; qq=sscanf(fptr,"%127s%n",str,&nu); nused+=nu;fptr+=nu; \
      if( str[0]=='\0' || qq==0 || nu==0 ) goto Finished ;                \
    } while(0)

do{ GETSSS ;                                                            \
      while(str[0]=='!' || (str[0]=='/' && str[1]=='/') ||                \
            (str[0]=='#' && str[1]=='\0') ){EOLSKIP; GETSSS;}             \
    } while(0)

do{ int iq ; (name) = (RENDER_state_array *) malloc(sizeof(RENDER_state_array)) ; \
         (name)->num = 0 ; (name)->nall = INC_RSA ;                                   \
         (name)->rsarr = (RENDER_state **)malloc(sizeof(RENDER_state *)*INC_RSA) ;   \
         for( iq=0 ; iq < INC_RSA ; iq++ ) (name)->rsarr[iq] = NULL ;               \
         break ; } while(0)

( ( (ds)->daxes->xxorient == ORI_L2R_TYPE ) && \
                            ( (ds)->daxes->yyorient == ORI_P2A_TYPE ) && \
                            ( (ds)->daxes->zzorient == ORI_I2S_TYPE )     )

( ( (ds)->daxes->xxorient == ORI_R2L_TYPE ) && \
                            ( (ds)->daxes->yyorient == ORI_A2P_TYPE ) && \
                            ( (ds)->daxes->zzorient == ORI_I2S_TYPE )     )

(void) XtVaCreateManagedWidget(                            \
            "dialog" , xmSeparatorWidgetClass , script_menu , \
             XmNseparatorType , XmSINGLE_LINE , NULL )

if( rs->nnn[0] != '\0' && RSDIFF_STR(nnn) ) \
      sss = THD_zzprintf( sss , "  " #nnn " = %s\n" , rs->nnn )

wname =                                                    \
         XtVaCreateManagedWidget(                              \
            "dialog" , xmPushButtonWidgetClass , script_menu , \
               LABEL_ARG( label ) ,                            \
               XmNmarginHeight , 0 ,                           \
               XmNtraversalOn , False ,                        \
               XmNinitialResourcesPersistent , False ,         \
            NULL ) ;                                           \
      XtAddCallback( wname , XmNactivateCallback ,             \
                     REND_script_CB , NULL ) ;

XtVaCreateManagedWidget(                     \
                       "AFNI" , xmSeparatorWidgetClass , (ww) ,   \
                          XmNseparatorType , XmSINGLE_LINE ,      \
                          XmNinitialResourcesPersistent , False , \
                       NULL )

XtVaCreateManagedWidget(                      \
                       "AFNI" , xmSeparatorWidgetClass , (ww) ,   \
                          XmNseparatorType , XmDOUBLE_LINE ,      \
                          XmNorientation   , XmVERTICAL ,         \
                          XmNinitialResourcesPersistent , False , \
                       NULL )

do{ XmString xstr ;                                              \
      xstr = XmStringCreateLtoR( NO_DATASET_STRING ,                \
                                 XmFONTLIST_DEFAULT_TAG ) ;          \
      XtVaSetValues( wfunc_info_lab , XmNlabelString,xstr , NULL ) ;  \
      XmStringFree(xstr) ;                                             \
                                                                        \
      xstr = REND_range_label() ;                                        \
      XtVaSetValues( wfunc_range_label , XmNlabelString , xstr , NULL ) ; \
      XmStringFree(xstr) ;                                                 \
                                                                            \
      xstr = REND_autorange_label() ;                                        \
      XtVaSetValues( wfunc_range_bbox->wbut[0], XmNlabelString,xstr, NULL ) ; \
      XmStringFree(xstr) ;                                                    \
                                                                             \
      AV_SENSITIZE( wfunc_color_av  , False ) ;                             \
      AV_SENSITIZE( wfunc_thresh_av , False ) ;                            \
  } while(0)

(( ISVALID_DSET(ds)                      )          && \
     ( DSET_INMEMORY(ds)                     )          && \
     ( DSET_CUBICAL(ds)                      )          && \
     ( DSET_BRICK_TYPE(ds,0) == MRI_short ||               \
       DSET_BRICK_TYPE(ds,0) == MRI_byte  ||               \
      (DSET_BRICK_TYPE(ds,0) == MRI_float && float_ok)) && \
     IS_AXIAL(ds)                                            )

00594   {
00595      GRAF_get_setup( gp , &(gs->nh) , gs->xh , gs->yh , &(gs->spl) ) ;
00596      return ;
00597   }

00600   {
00601      GRAF_put_setup( gp , gs->nh , gs->xh , gs->yh , gs->spl ) ;
00602      return ;
00603   }

00583   {  int ii ;
00584      if( g1->nh  != g2->nh  ) return 0 ;
00585      if( g1->spl != g2->spl ) return 0 ;
00586      for( ii=0 ; ii < g1->nh ; ii++ ){
00587         if( g1->xh[ii] != g2->xh[ii] ) return 0 ;
00588         if( g1->yh[ii] != g2->yh[ii] ) return 0 ;
00589      }
00590      return 1 ;
00591   }

00115 {
00116    char * env ;
00117    float  val ;
00118    int    ii  ;
00119 
00120    if( ncall > 0 ) return NULL ;  /* only one interface */
00121 
00122    plint = PLUTO_new_interface( "Render Dataset" , NULL , NULL ,
00123                                 PLUGIN_CALL_IMMEDIATELY , REND_main ) ;
00124 
00125    PLUTO_add_hint( plint , "Volume Rendering" ) ;
00126 
00127    PLUTO_set_sequence( plint , "A:graphics" ) ;
00128 
00129    /***----- retrieve relevant environment variables, if any -----***/
00130 
00131    env = getenv("AFNI_RENDER_ANGLE_DELTA") ;
00132    if( env != NULL ){
00133       val = strtod(env,NULL) ;
00134       if( val > 0.0 && val < 100.0 ) angle_fstep = val ;
00135    }
00136    PLUTO_register_environment_numeric( "AFNI_RENDER_ANGLE_DELTA" ,
00137                                        "Angle stepsize in deg (volume renderer)" ,
00138                                        1,9,0,(int)angle_fstep, REND_environ_CB );
00139 
00140    /*--*/
00141 
00142    env = getenv("AFNI_RENDER_CUTOUT_DELTA") ;
00143    if( env != NULL ){
00144       val = strtod(env,NULL) ;
00145       if( val > 0.0 && val < 100.0 ) cutout_fstep = val ;
00146    }
00147    PLUTO_register_environment_numeric( "AFNI_RENDER_CUTOUT_DELTA" ,
00148                                        "Cutout stepsize in mm (volume renderer)" ,
00149                                        1,9,0,(int)cutout_fstep, REND_environ_CB );
00150 
00151    /*--*/
00152 
00153    env = getenv("AFNI_RENDER_PRECALC_MODE") ;
00154    if( env != NULL ){
00155       for( ii=0 ; ii < NUM_precalc ; ii++ )
00156          if( strcmp(env,precalc_strings[ii]) == 0 ) break ;
00157       if( ii < NUM_precalc ) precalc_ival = precalc_mode[ii] ;
00158    }
00159 
00160    /*--*/
00161 
00162    env = getenv("AFNI_RENDER_SHOWTHRU_FAC") ;
00163    if( env != NULL ){
00164       val = strtod(env,NULL) ;
00165       if( val < 0.0 || val > 1.0 ) val = 1.0 ;
00166    } else {
00167       val = 1.0 ;
00168    }
00169    PLUTO_register_environment_numeric( "AFNI_RENDER_SHOWTHRU_FAC" ,
00170                                        "ShowThru mixing factor (volume renderer)",
00171                                        30,100,2,(int)rint(100.0*val) , NULL ) ;
00172 
00173    /*-- done --*/
00174 
00175    return plint ;
00176 }

03633 {
03634    accum_flag = MCW_val_bbox( accum_bbox ) ;
03635    return ;
03636 }

03354 {
03355    float na ;
03356 
03357 /*==========================================================================*/
03358 #ifdef ALLOW_INCROT  /* 26 Apr 2002 - RWCox */
03359    if( cd == NULL && MCW_val_bbox(incrot_bbox) ){  /* increment mode  */
03360       REND_do_incrot( av ) ;                       /* ==> do work here */
03361       return ;
03362    }
03363 #endif
03364 /*==========================================================================*/
03365 
03366    if( av == roll_av  ){
03367 
03368       na = angle_roll = av->fval ;
03369            if( na <    0.0 ) na += 360 ;
03370       else if( na >= 360.0 ) na -= 360.0 ;
03371       if( na != av->fval ){ AV_assign_fval( av , na ) ; angle_roll = na ; }
03372 
03373    } else if( av == pitch_av ){
03374 
03375      na = angle_pitch = av->fval ;
03376            if( na <    0.0 ) na += 360 ;
03377       else if( na >= 360.0 ) na -= 360.0 ;
03378       if( na != av->fval ){ AV_assign_fval( av , na ) ; angle_pitch = na ; }
03379 
03380    } else if( av == yaw_av   ){
03381 
03382       na = angle_yaw = av->fval ;
03383            if( na <    0.0 ) na += 360 ;
03384       else if( na >= 360.0 ) na -= 360.0 ;
03385       if( na != av->fval ){ AV_assign_fval( av , na ) ; angle_yaw = na ; }
03386 
03387    } else {
03388       return ;  /* should never happen */
03389    }
03390 
03391    if( cd == NULL && dynamic_flag && render_handle != NULL )
03392       REND_draw_CB(NULL,NULL,NULL) ;
03393 
03394    return ;
03395 }

04679 {
04680    if( autokill ){ XBell(dc->display,100) ; return ; }
04681    autokill = 1 ;
04682 }

04627 {
04628    int it , ntime = autoframe_av->ival ;
04629    float scl = 100.0/ntime ;
04630    Widget autometer ;
04631 
04632    automate_flag = 1 ;
04633    if( ! accum_flag ){
04634       DESTROY_IMARR(renderings) ;
04635 #ifdef USE_SCRIPTING
04636       DESTROY_RSA(renderings_state) ;
04637 #endif
04638    }
04639 
04640    atoz[N_IND] = ntime ;
04641 
04642    autometer = MCW_popup_meter( shell , METER_TOP_WIDE ) ;
04643 
04644    XtManageChild( autocancel_pb ) ; AFNI_add_interruptable( autocancel_pb ) ;
04645    autokill = 0 ;
04646 
04647    for( it=0 ; it < ntime ; it++ ){
04648       atoz[T_IND] = it ;
04649       AV_assign_ival( autoframe_av , it+1 ) ;
04650 
04651       REND_draw_CB(NULL,NULL,NULL) ;
04652 
04653       if( it < ntime-1 ){
04654          AFNI_process_interrupts(autocancel_pb) ;
04655          if( autokill ) break ;
04656       }
04657 
04658       MCW_set_meter( autometer , (int)(scl*(it+1)) ) ;
04659    }
04660 
04661    MCW_popdown_meter( autometer ) ;
04662 
04663    /*-- done: turn off automation --*/
04664 
04665    MCW_set_bbox( automate_bbox , 0 ) ;
04666    XtSetSensitive( autocompute_pb , False ) ;
04667 
04668    XtUnmanageChild( autocancel_pb ) ; AFNI_add_interruptable(NULL) ;
04669 
04670    automate_flag = 0 ;
04671    return ;
04672 }

04609 {
04610    int flag = MCW_val_bbox( automate_bbox ) ;
04611    XtSetSensitive( autocompute_pb , (Boolean) flag ) ;
04612 
04613 #ifdef ALLOW_INCROT  /* 26 Apr 2002 - RWCox */
04614    if( flag ) MCW_set_bbox( incrot_bbox , 0 ) ;
04615 #endif
04616 
04617    return ;
04618 }

05654 {
05655    XmString xstr ;
05656    float rrr = DEFAULT_FUNC_RANGE ;
05657    char buf[32] , qbuf[16] ;
05658 
05659    if( ISVALID_DSET(func_dset) ){
05660 
05661       RELOAD_STATS(func_dset) ;
05662       if( ISVALID_STATISTIC(func_dset->stats) ){
05663          float s1 , s2 ; int iv ;
05664 
05665          iv = func_color_ival ;
05666 
05667          if( DSET_VALID_BSTAT(func_dset,iv) ){
05668             s1  = fabs(func_dset->stats->bstat[iv].min) ,
05669             s2  = fabs(func_dset->stats->bstat[iv].max) ;
05670             rrr = (s1<s2) ? s2 : s1 ;
05671             if( rrr == 0.0 ) rrr = 1.0 ;
05672          }
05673       }
05674    }
05675 
05676    func_autorange = rrr ;
05677    AV_fval_to_char( rrr , qbuf ) ;
05678    sprintf( buf , "autoRange:%s" , qbuf ) ;
05679    xstr = XmStringCreateLtoR( buf , XmFONTLIST_DEFAULT_TAG ) ;
05680 
05681    return xstr ;
05682 }

04689 {
04690    XmString xstr ;
04691    char str[2*THD_MAX_NAME] ;
04692 
04693    /*--- selection of a underlay sub-brick ---*/
04694 
04695    if( av == choose_av && dset != NULL && av->ival < DSET_NVALS(dset) ){
04696 
04697       float fac = DSET_BRICK_FACTOR(dset,av->ival) ;
04698 
04699       if( fac == 0.0 || fac == 1.0 ){  /* rewrite the informational label */
04700          strcpy(str,dset_title) ;
04701       } else {
04702          char abuf[16] ;
04703          AV_fval_to_char( fac , abuf ) ;
04704          sprintf(str,"%s [* %s]", dset_title , abuf ) ;
04705       }
04706       xstr = XmStringCreateLtoR( str , XmFONTLIST_DEFAULT_TAG ) ;
04707       XtVaSetValues( info_lab , XmNlabelString , xstr , NULL ) ;
04708       XmStringFree(xstr) ;
04709 
04710       dset_ival = av->ival ;   /* read this sub-brick    */
04711       new_dset = 1 ;           /* flag it as new         */
04712       FREE_VOLUMES ;           /* free the internal data */
04713       REND_reload_dataset() ;  /* load the data          */
04714 
04715       if( render_handle != NULL ) REND_draw_CB(NULL,NULL,NULL) ; /* draw */
04716 
04717    /*--- selection of overlay color sub-brick ---*/
04718 
04719    } else if( av == wfunc_color_av && func_dset != NULL && av->ival < DSET_NVALS(func_dset) ){
04720 
04721       float fac = DSET_BRICK_FACTOR(func_dset,av->ival) ;
04722 
04723       if( fac == 0.0 || fac == 1.0 ){  /* rewrite the informational label */
04724          strcpy(str,func_dset_title) ;
04725       } else {
04726          char abuf[16] ;
04727          AV_fval_to_char( fac , abuf ) ;
04728          sprintf(str,"%s [* %s]", func_dset_title , abuf ) ;
04729       }
04730       xstr = XmStringCreateLtoR( str , XmFONTLIST_DEFAULT_TAG ) ;
04731       XtVaSetValues( wfunc_info_lab , XmNlabelString , xstr , NULL ) ;
04732       XmStringFree(xstr) ;
04733 
04734       func_color_ival = av->ival ;
04735 
04736       /* fix the range labels */
04737 
04738       xstr = REND_range_label() ;
04739       XtVaSetValues( wfunc_range_label , XmNlabelString , xstr , NULL ) ;
04740       XmStringFree(xstr) ;
04741 
04742       xstr = REND_autorange_label() ;
04743       XtVaSetValues( wfunc_range_bbox->wbut[0], XmNlabelString,xstr , NULL ) ;
04744       XmStringFree(xstr) ;
04745 
04746       INVALIDATE_OVERLAY ;
04747 
04748       AFNI_hintize_pbar( wfunc_color_pbar , FUNC_RANGE ) ; /* 30 Jul 2001 */
04749 
04750    /*--- selection of overlay threshold sub-brick ---*/
04751 
04752    } else if( av == wfunc_thresh_av && func_dset != NULL && av->ival < DSET_NVALS(func_dset) ){
04753 
04754       func_thresh_ival = av->ival ;
04755 
04756       /* fix the range label */
04757 
04758       xstr = REND_range_label() ;
04759       XtVaSetValues( wfunc_range_label , XmNlabelString , xstr , NULL ) ;
04760       XmStringFree(xstr) ;
04761 
04762       /* fix the p-value label */
04763 
04764       REND_set_thr_pval() ;
04765 
04766       INVALIDATE_OVERLAY ;
04767    }
04768 
04769    return ;
04770 }

04777 {
04778    static char blab[32] ;
04779    THD_3dim_dataset * dset = (THD_3dim_dataset *) cd ;
04780    static char * lfmt[3] = { "#%1d %-14.14s" , "#%2d %-14.14s" , "#%3d %-14.14s"  } ;
04781    static char * rfmt[3] = { "%-14.14s #%1d" , "%-14.14s #%2d" , "%-14.14s #%3d"  } ;
04782 
04783    if( ISVALID_3DIM_DATASET(dset) ){
04784 
04785 #ifdef USE_RIGHT_BUCK_LABELS
04786       if( DSET_NVALS(dset) < 10 )
04787         sprintf(blab, rfmt[0] , DSET_BRICK_LABEL(dset,av->ival) , av->ival ) ;
04788       else if( DSET_NVALS(dset) < 100 )
04789         sprintf(blab, rfmt[1] , DSET_BRICK_LABEL(dset,av->ival) , av->ival ) ;
04790       else
04791         sprintf(blab, rfmt[2] , DSET_BRICK_LABEL(dset,av->ival) , av->ival ) ;
04792 #else
04793       if( DSET_NVALS(dset) < 10 )
04794         sprintf(blab, lfmt[0] , av->ival , DSET_BRICK_LABEL(dset,av->ival) ) ;
04795       else if( DSET_NVALS(dset) < 100 )
04796         sprintf(blab, lfmt[1] , av->ival , DSET_BRICK_LABEL(dset,av->ival) ) ;
04797       else
04798         sprintf(blab, lfmt[2] , av->ival , DSET_BRICK_LABEL(dset,av->ival) ) ;
04799 #endif
04800    }
04801    else
04802       sprintf(blab," #%d ",av->ival) ;  /* should not happen! */
04803 
04804    return blab ;
04805 }

03028 {
03029    int vv = im3d->vinfo->view_type ; /* view type */
03030    THD_3dim_dataset * qset ;
03031    int id , ltop , llen , dofunc ;
03032    char qnam[THD_MAX_NAME] , label[THD_MAX_NAME] ;
03033    static char ** strlist = NULL ;
03034 
03035    int isl = -2 ;     /* 03 Apr 1999 */
03036    MCW_idcode midc ;
03037 
03038    /*-- decide if we want overlay (func) or underlay --*/
03039 
03040    dofunc = (w == wfunc_choose_pb) ;
03041 
03042    if( dofunc && !ISVALID_DSET(dset) ){
03043       (void) MCW_popup_message( w ,
03044                                    "Can't choose overlay\nbefore underlay!" ,
03045                                 MCW_USER_KILL | MCW_TIMER_KILL ) ;
03046       XBell(dc->display,100) ; return ;
03047    }
03048 
03049    if( dofunc )
03050       REND_load_dsl( dset , 1 ) ;
03051    else
03052       REND_load_dsl( NULL , 0 ) ;
03053 
03054    /* found nothing?  exit */
03055 
03056    if( ndsl < 1 ){
03057       (void) MCW_popup_message( w ,
03058                                    "Didn't find\nany datasets\nto render!" ,
03059                                 MCW_USER_KILL | MCW_TIMER_KILL ) ;
03060       XBell(dc->display,100) ; return ;
03061    }
03062 
03063    /*--- loop over dataset links and patch their titles
03064          to include an indicator of the dataset type    ---*/
03065 
03066    ltop = 4 ;
03067    for( id=0 ; id < ndsl ; id++ ){
03068       llen = strlen(dsl[id].title) ;
03069       ltop = MAX(ltop,llen) ;
03070    }
03071 
03072    for( id=0 ; id < ndsl ; id++ ){
03073       qset = PLUTO_find_dset( &(dsl[id].idcode) ) ;
03074       if( ! ISVALID_DSET(qset) ) continue ;
03075       if( ISANAT(qset) ){
03076          if( ISANATBUCKET(qset) )         /* 30 Nov 1997 */
03077             sprintf(qnam,"%-*s [%s:%d]" ,
03078                     ltop,dsl[id].title ,
03079                     ANAT_prefixstr[qset->func_type] , DSET_NVALS(qset) ) ;
03080 
03081          else if( DSET_NUM_TIMES(qset) == 1 )
03082             sprintf(qnam,"%-*s [%s]" ,
03083                     ltop,dsl[id].title ,
03084                     ANAT_prefixstr[qset->func_type] ) ;
03085 
03086          else
03087             sprintf(qnam,"%-*s [%s:3D+t:%d]" ,
03088                     ltop,dsl[id].title ,
03089                     ANAT_prefixstr[qset->func_type] , DSET_NUM_TIMES(qset) ) ;
03090 
03091       } else {
03092          if( ISFUNCBUCKET(qset) )         /* 30 Nov 1997 */
03093             sprintf(qnam,"%-*s [%s:%d]" ,
03094                     ltop,dsl[id].title ,
03095                     FUNC_prefixstr[qset->func_type] , DSET_NVALS(qset) ) ;
03096 
03097          else if( DSET_NUM_TIMES(qset) == 1 )
03098             sprintf(qnam,"%-*s [%s]" ,
03099                     ltop,dsl[id].title ,
03100                     FUNC_prefixstr[qset->func_type] ) ;
03101 
03102          else
03103             sprintf(qnam,"%-*s [%s:3D+t:%d]" ,
03104                     ltop,dsl[id].title ,
03105                     FUNC_prefixstr[qset->func_type] , DSET_NVALS(qset) ) ;
03106       }
03107 
03108       if( DSET_COMPRESSED(qset) ) strcat(qnam,"z") ;
03109 
03110       strcpy( dsl[id].title , qnam ) ;
03111    }
03112 
03113    /*--- make a popup chooser for the user to browse ---*/
03114 
03115    POPDOWN_strlist_chooser ;
03116 
03117    strlist = (char **) XtRealloc( (char *)strlist , sizeof(char *)*ndsl ) ;
03118    for( id=0 ; id < ndsl ; id++ ) strlist[id] = dsl[id].title ;
03119 
03120    /*-- 03 Apr 1999: set the initial selection in the chooser --*/
03121 
03122         if(  dofunc && func_dset != NULL ){ midc = func_dset_idc; isl = -1; }
03123    else if( !dofunc && dset      != NULL ){ midc = dset_idc     ; isl = -1; }
03124 
03125    if( isl == -1 ){
03126       for( id=0 ; id < ndsl ; id++ ){
03127          if( EQUIV_IDCODES(midc,dsl[id].idcode) ){ isl = id ; break ; }
03128       }
03129    }
03130 
03131    /*-- popup the chooser -- */
03132 
03133    sprintf( label , "AFNI Dataset from\nthe %s" , VIEW_typestr[vv] ) ;
03134 
03135    MCW_choose_strlist( w , label , ndsl , isl , strlist ,
03136                        (dofunc) ? REND_finalize_func_CB
03137                                 : REND_finalize_dset_CB , NULL ) ;
03138 
03139    return ;
03140 }

03720 {
03721    FREE_VOLUMES ;  /* free the volumes, will force reloading */
03722 
03723    if( clipbot_av->ival >= cliptop_av->ival ){
03724       if( av == clipbot_av )
03725          AV_assign_ival( clipbot_av , cliptop_av->ival - 1 ) ;
03726       else
03727          AV_assign_ival( cliptop_av , clipbot_av->ival + 1 ) ;
03728    }
03729 
03730    /* if brick is scaled, re-show the scaled labels */
03731 
03732    if( brickfac != 0.0 && brickfac != 1.0 ){
03733       char minch[16] , maxch[16] , str[64] ;
03734       XmString xstr ;
03735 
03736       if( av == clipbot_av ){
03737          AV_fval_to_char( brickfac * clipbot_av->ival , minch ) ;
03738          sprintf(str,"[-> %s]",minch) ;
03739          xstr = XmStringCreateLtoR( str , XmFONTLIST_DEFAULT_TAG ) ;
03740          XtVaSetValues( clipbot_faclab , XmNlabelString , xstr , NULL ) ;
03741          XmStringFree(xstr) ;
03742       } else {
03743          AV_fval_to_char( brickfac * cliptop_av->ival , maxch ) ;
03744          sprintf(str,"[-> %s]",maxch) ;
03745          xstr = XmStringCreateLtoR( str , XmFONTLIST_DEFAULT_TAG ) ;
03746          XtVaSetValues( cliptop_faclab , XmNlabelString , xstr , NULL ) ;
03747          XmStringFree(xstr) ;
03748       }
03749    }
03750 
03751    return ;
03752 }

05978 {
05979    int cc ;
05980 
05981    INVALIDATE_OVERLAY ;
05982 
05983    for( cc=0 ; cc < current_cutout_state.num ; cc++ )
05984       if( current_cutout_state.type[cc] == CUT_NONOVERLAY ){
05985          FREE_VOLUMES ;
05986          break ;
05987       }
05988 
05989    return ;
05990 }

05870 {
05871    int jm , newpos=MCW_val_bbox(wfunc_color_bbox) ;
05872 
05873    if( newpos == func_posfunc ) return ;  /* no change? */
05874 
05875    func_posfunc = newpos ;
05876    jm = wfunc_color_pbar->mode = (newpos) ? 1 : 0 ;  /* pbar mode */
05877 
05878    HIDE_SCALE ;
05879    alter_MCW_pbar( wfunc_color_pbar , wfunc_color_pbar->npan_save[jm] , NULL ) ;
05880    FIX_SCALE_SIZE ;
05881 
05882    /* set the count on the pbar control arrowval to match */
05883 
05884    AV_assign_ival( wfunc_colornum_av , wfunc_color_pbar->npan_save[jm] ) ;
05885 
05886    INVALIDATE_OVERLAY ;
05887    return ;
05888 }

05895 {
05896    int ofs = func_showthru ;
05897    func_color_opacity = 0.1 * av->ival ;
05898    func_showthru = (av->ival == 11 || av->ival == 12) ;    /* 07 Jan 2000 */
05899    func_showthru_dcue = ( av->ival == 12 ) ;               /* 11 Sep 2001 */
05900    INVALIDATE_OVERLAY ;
05901 
05902    if( func_showthru != ofs ) FREE_VOLUMES ;
05903    return ;
05904 }

05844 {
05845    FIX_SCALE_SIZE ;
05846    INVALIDATE_OVERLAY ;
05847 
05848    AFNI_hintize_pbar( wfunc_color_pbar , FUNC_RANGE ) ; /* 30 Mar 2001 */
05849    return ;
05850 }

05857 {
05858    HIDE_SCALE ;
05859    alter_MCW_pbar( wfunc_color_pbar , av->ival , NULL ) ;
05860    FIX_SCALE_SIZE ;
05861    INVALIDATE_OVERLAY ;
05862    return ;
05863 }

05941 {
05942    int newcut = MCW_val_bbox(wfunc_cut_overlay_bbox) ;
05943 
05944    if( newcut == func_cut_overlay ) return ;
05945 
05946    func_cut_overlay = newcut ;
05947    if( num_cutouts > 0 ){ INVALIDATE_OVERLAY ; }
05948    return ;
05949 }

03995 {
03996    int ii,jj,kk , nx,ny,nz,nxy,nxyz , cc , typ , ncc,logic,nmust,nand,mus ;
03997    int ibot,itop , jbot,jtop , kbot,ktop ;
03998    float par ;
03999    float dx,dy,dz , xorg,yorg,zorg , xx,yy,zz ;
04000    byte * oar , * gar ;
04001    byte ncdone = 0 ;
04002 
04003    ncc   = current_cutout_state.num ;
04004    logic = current_cutout_state.logic ;
04005    if( ncc < 1 || oppim == NULL ) return ;      /* error */
04006 
04007    /* find out if the logic is effectively "OR" */
04008 
04009    if( ncc == 1 ){
04010       logic = CUTOUT_OR ;
04011    } else {
04012       for( nmust=cc=0 ; cc < ncc ; cc++ )
04013          if( current_cutout_state.mustdo[cc] ) nmust++ ;
04014       if( nmust >= ncc-1 ) logic = CUTOUT_OR ;
04015    }
04016 
04017    /* initialize */
04018 
04019    oar = MRI_BYTE_PTR(oppim) ; if( oar == NULL ) return ;
04020    nx  = oppim->nx ;
04021    ny  = oppim->ny ; nxy  = nx * ny ;
04022    nz  = oppim->nz ; nxyz = nxy * nz ;
04023 
04024    if( logic == CUTOUT_AND ){
04025       gar = (byte *) malloc( sizeof(byte) * nxyz ) ;  /* counts of hits */
04026       memset( gar , 0 , sizeof(byte) * nxyz ) ;
04027    }
04028 
04029    dx   = dset->daxes->xxdel; dy   = dset->daxes->yydel; dz   = dset->daxes->zzdel;
04030    xorg = dset->daxes->xxorg; yorg = dset->daxes->yyorg; zorg = dset->daxes->zzorg;
04031 
04032    for( cc=0 ; cc < ncc ; cc++ ){              /* loop over cutouts */
04033       typ = current_cutout_state.type[cc] ;
04034       mus = current_cutout_state.mustdo[cc] ;
04035       par = current_cutout_state.param[cc] ;
04036       if( typ == CUT_NONE ) continue ;         /* error */
04037 
04038       switch( typ ){
04039 
04040          /*............................................................*/
04041 
04042          case CUT_RIGHT_OF:
04043          case CUT_LEFT_OF:
04044          case CUT_ANTERIOR_TO:
04045          case CUT_POSTERIOR_TO:
04046          case CUT_INFERIOR_TO:
04047          case CUT_SUPERIOR_TO:{         /* a rectangular region */
04048            int q ;
04049 
04050            ibot = 0 ; itop = nx-1 ;     /* everything */
04051            jbot = 0 ; jtop = ny-1 ;
04052            kbot = 0 ; ktop = nz-1 ;
04053            switch( typ ){
04054               case CUT_RIGHT_OF:
04055                  q = (int)( (par-xorg)/dx - 0.499 ); RANGE(q,0,itop); itop = q;
04056               break ;
04057               case CUT_LEFT_OF:
04058                  q = (int)( (par-xorg)/dx + 1.499 ); RANGE(q,0,itop); ibot = q;
04059               break ;
04060               case CUT_ANTERIOR_TO:
04061                  q = (int)( (par-yorg)/dy - 0.499 ); RANGE(q,0,jtop); jtop = q;
04062               break ;
04063               case CUT_POSTERIOR_TO:
04064                  q = (int)( (par-yorg)/dy + 1.499 ); RANGE(q,0,jtop); jbot = q;
04065               break ;
04066               case CUT_INFERIOR_TO:
04067                  q = (int)( (par-zorg)/dz - 0.499 ); RANGE(q,0,ktop); ktop = q;
04068               break ;
04069               case CUT_SUPERIOR_TO:
04070                  q = (int)( (par-zorg)/dz + 1.499 ); RANGE(q,0,ktop); kbot = q;
04071               break ;
04072            }
04073 
04074            if( logic == CUTOUT_AND && ! mus ){        /* count hits */
04075               ncdone++ ;
04076               for( kk=kbot ; kk <= ktop ; kk++ )
04077                  for( jj=jbot ; jj <= jtop ; jj++ )
04078                     for( ii=ibot ; ii <= itop ; ii++ ) GR(ii,jj,kk)++ ;
04079 
04080            } else {                                   /* just blast it */
04081               for( kk=kbot ; kk <= ktop ; kk++ )
04082                  for( jj=jbot ; jj <= jtop ; jj++ )
04083                     for( ii=ibot ; ii <= itop ; ii++ ) OP(ii,jj,kk) = 0 ;
04084            }
04085          }
04086          break ;  /* end of rectangular region cutout */
04087 
04088          /*............................................................*/
04089 
04090          case CUT_TT_ELLIPSOID:{                 /* an ellipsoid */
04091 
04092            float dxa=dx/TT_XSEMI  , dya=dy/TT_YSEMI  , dza=dz/TT_ZSEMI   ;
04093            float xga=(xorg-TT_XMID)/TT_XSEMI ,
04094                  yga=(yorg-TT_YMID)/TT_YSEMI ,
04095                  zga=(zorg-TT_ZMID)/TT_ZSEMI , ebot=0.0001*par*par ;
04096 
04097            if( logic == CUTOUT_AND && ! mus ){        /* count hits */
04098               ncdone++ ;
04099               for( kk=0 ; kk < nz ; kk++ ){
04100                 zz = zga + kk*dza ; zz = zz*zz ;
04101                 for( jj=0 ; jj < ny ; jj++ ){
04102                   yy = yga + jj*dya ; yy = yy*yy + zz ;
04103                   if( yy < ebot ){
04104                     for( ii=0 ; ii < nx ; ii++ ){
04105                       xx = xga + ii*dxa ; xx = xx*xx + yy ;
04106                       if( xx > ebot ) GR(ii,jj,kk)++ ;
04107                     }
04108                   } else {
04109                     for( ii=0 ; ii < nx ; ii++ ) GR(ii,jj,kk)++ ;
04110                   }
04111               }}
04112 
04113            } else {                                   /* blast it */
04114               for( kk=0 ; kk < nz ; kk++ ){
04115                 zz = zga + kk*dza ; zz = zz*zz ;
04116                 for( jj=0 ; jj < ny ; jj++ ){
04117                   yy = yga + jj*dya ; yy = yy*yy + zz ;
04118                   if( yy < ebot ){
04119                     for( ii=0 ; ii < nx ; ii++ ){
04120                       xx = xga + ii*dxa ; xx = xx*xx + yy ;
04121                       if( xx > ebot ) OP(ii,jj,kk) = 0 ;
04122                     }
04123                   } else {
04124                     for( ii=0 ; ii < nx ; ii++ ) OP(ii,jj,kk) = 0 ;
04125                   }
04126               }}
04127            }
04128          }
04129          break ;  /* end of ellipsoid cutout */
04130 
04131          /*............................................................*/
04132 
04133 #define VSIZE nx
04134          case CUT_EXPRESSION:{      /* expression > 0 */
04135             PARSER_code * pcode ;
04136             double * abc[26] , * temp ;
04137 
04138             /* parse the expression */
04139 
04140             pcode = PARSER_generate_code( current_cutout_state.param_str[cc] ) ;
04141             if( pcode == NULL ) break ;  /* skip this cutout */
04142 
04143             /* create the evaluation workspaces */
04144 
04145             temp = (double *) malloc( sizeof(double) * VSIZE ) ;
04146             for( jj=0 ; jj < 26 ; jj++ )
04147                abc[jj] = (double *) malloc( sizeof(double) * VSIZE ) ;
04148 
04149             for( jj=0 ; jj < 23 ; jj++ )       /* load zeros for */
04150                for( ii=0 ; ii < VSIZE; ii++ )  /* 'a' ... 'w'    */
04151                   abc[jj][ii] = 0.0 ;
04152 
04153             for( ii=0 ; ii < VSIZE ; ii++ ){   /* load 't' and 'n' */
04154                abc[N_IND][ii] = atoz[N_IND] ;
04155                abc[T_IND][ii] = atoz[T_IND] ;
04156             }
04157 
04158             /* loop over rows of voxels and evaluate expressions */
04159 
04160             for( kk=0 ; kk < nz ; kk++ ){
04161               zz = zorg + kk*dz ;
04162               for( jj=0 ; jj < ny ; jj++ ){
04163                 yy = yorg + jj*dy ;
04164 
04165                 for( ii=0 ; ii < nx ; ii++ ){      /* load row */
04166                    abc[X_IND][ii] = xorg + ii*dx ;
04167                    abc[Y_IND][ii] = yy ;
04168                    abc[Z_IND][ii] = zz ;
04169                 }
04170 
04171                 /* evaluate the expression */
04172 
04173                 PARSER_evaluate_vector(pcode, abc, VSIZE, temp);
04174 
04175                 /* cut cut cut */
04176 
04177                 if( logic == CUTOUT_AND && ! mus ){        /* count hits */
04178                    for( ii=0 ; ii < nx ; ii++ )
04179                      if( temp[ii] > 0.0 ) GR(ii,jj,kk)++ ;
04180 
04181                 } else {                                   /* blast'em */
04182                    for( ii=0 ; ii < nx ; ii++ )
04183                      if( temp[ii] > 0.0 ) OP(ii,jj,kk) = 0 ;
04184                 }
04185             }} /* end of loops over jj,kk (y,z) */
04186 
04187             if( logic == CUTOUT_AND && ! mus ) ncdone++ ;
04188 
04189             /* free workspaces */
04190 
04191             for( jj=0 ; jj < 26 ; jj++ ) free(abc[jj]) ;
04192             free(temp) ; free(pcode) ;
04193          }
04194          break ;  /* end of expression cutout */
04195 
04196          /*............................................................*/
04197 
04198          case CUT_SLANT_XPY_GT:   /* the slanted cut planes */
04199          case CUT_SLANT_XPY_LT:
04200          case CUT_SLANT_XMY_GT:
04201          case CUT_SLANT_XMY_LT:
04202          case CUT_SLANT_YPZ_GT:
04203          case CUT_SLANT_YPZ_LT:
04204          case CUT_SLANT_YMZ_GT:
04205          case CUT_SLANT_YMZ_LT:
04206          case CUT_SLANT_XPZ_GT:
04207          case CUT_SLANT_XPZ_LT:
04208          case CUT_SLANT_XMZ_GT:
04209          case CUT_SLANT_XMZ_LT:{
04210             int isl = typ - CUT_SLANT_BASE ;
04211             float xn = cut_slant_normals[isl][0] , dxn = dx * xn ,
04212                   yn = cut_slant_normals[isl][1] , dyn = dy * yn ,
04213                   zn = cut_slant_normals[isl][2] , dzn = dz * zn , pval ;
04214 
04215             pval = par - xn*xorg - yn*yorg - zn*zorg ;
04216 
04217             if( logic == CUTOUT_AND && ! mus ){        /* count hits */
04218               ncdone++ ;
04219               for( kk=0,zz=-pval ; kk < nz ; kk++,zz+=dzn ){
04220                 /* zz = kk * dzn - pval ; */
04221                 for( jj=0,yy=zz ; jj < ny ; jj++,yy+=dyn ){
04222                   /* yy = jj * dyn + zz ; */
04223                   for( ii=0,xx=yy ; ii < nx ; ii++,xx+=dxn ){
04224                     /* xx = ii * dxn + yy ; */
04225                     if( xx > 0.0 ) GR(ii,jj,kk)++ ;
04226                   }
04227               }}
04228             } else {                                   /* blast it */
04229               for( kk=0,zz=-pval ; kk < nz ; kk++,zz+=dzn ){
04230                 /* zz = kk * dzn - pval ; */
04231                 for( jj=0,yy=zz ; jj < ny ; jj++,yy+=dyn ){
04232                   /* yy = jj * dyn + zz ; */
04233                   for( ii=0,xx=yy ; ii < nx ; ii++,xx+=dxn ){
04234                     /* xx = ii * dxn + yy ; */
04235                     if( xx > 0.0 ) OP(ii,jj,kk) = 0 ;
04236                   }
04237               }}
04238             }
04239          }
04240          break ;  /* end of slant cutout */
04241 
04242          /*............................................................*/
04243 
04244 #define OVAR(i,j,k) ovar[(i)+(j)*nx+(k)*nxy]
04245 #define KEEP(i,j,k) keep[(i)+(j)*nx+(k)*nxy]
04246 
04247          case CUT_NONOVERLAY:
04248          if( DO_OVERLAY ){  /* 24 Jul 2001: changed condition from func_dset != NULL */
04249             byte * ovar ;
04250             float adx=fabs(dx) , ady=fabs(dy) , adz=fabs(dz) ;
04251 
04252             if( ovim == NULL ) REND_reload_func_dset() ; /* get the global */
04253             ovar = MRI_BYTE_PTR(ovim) ;                  /* overlay image */
04254 
04255             if( par < adx && par < ady && par < adz ){   /* no dilation */
04256 
04257               if( logic == CUTOUT_AND && ! mus ){        /* count hits */
04258                 ncdone++ ;
04259                 for( ii=0 ; ii < nxyz ; ii++ )
04260                    if( ovar[ii] == 0 ) gar[ii]++ ;
04261               } else {                                   /* nuke'em */
04262                 for( ii=0 ; ii < nxyz ; ii++ )
04263                    if( ovar[ii] == 0 ) oar[ii] = 0 ;
04264               }
04265 
04266             } else {                                     /* dilation */
04267 
04268               MCW_cluster * mask = MCW_build_mask( nx,ny,nz, adx,ady,adz, par ) ;
04269               int mnum = mask->num_pt , pp,ip,jp,kp ;
04270               short * mi = mask->i , * mj = mask->j , * mk = mask->k ;
04271               byte * keep = calloc(nxyz,sizeof(byte)) ;
04272 
04273               for( kk=0 ; kk < nz ; kk++ )       /* make list of points to keep */
04274                 for( jj=0 ; jj < ny ; jj++ )
04275                   for( ii=0 ; ii < nx ; ii++ )
04276                      if( OVAR(ii,jj,kk) != 0 ){  /* keep nbhd of this point */
04277                         KEEP(ii,jj,kk) = 1 ;
04278                         for( pp=0 ; pp < mnum ; pp++ ){
04279                            ip = ii + mi[pp]; jp = jj + mj[pp]; kp = kk + mk[pp];
04280                            if( ip >= 0 && ip < nx &&
04281                                jp >= 0 && jp < ny &&
04282                                kp >= 0 && kp < nz   ) KEEP(ip,jp,kp) = 1 ;
04283                         }
04284                      }
04285               KILL_CLUSTER(mask) ;  /* toss the trash */
04286 
04287               /* now do the cutting */
04288 
04289               if( logic == CUTOUT_AND && ! mus ){        /* count hits */
04290                 ncdone++ ;
04291                 for( ii=0 ; ii < nxyz ; ii++ )
04292                    if( keep[ii] == 0 ) gar[ii]++ ;
04293               } else {                                   /* nuke'em */
04294                 for( ii=0 ; ii < nxyz ; ii++ )
04295                    if( keep[ii] == 0 ) oar[ii] = 0 ;
04296               }
04297 
04298               free(keep) ;  /* toss the trash */
04299             }
04300          }
04301          break ;  /* end of nonoverlay cutout */
04302 
04303       } /* end of switch over type of cutout */
04304    } /* end of loop over cutouts */
04305 
04306    /* with AND, blast only those that were hit every time */
04307 
04308    if( logic == CUTOUT_AND && ncdone > 0 ){
04309       for( ii=0 ; ii < nxyz ; ii++ ) if( gar[ii] == ncdone ) oar[ii] = 0 ;
04310       free(gar) ;
04311    }
04312 
04313    return ;
04314 }

03925 {
03926    int iv , typ ;
03927    float val ;
03928    char str[16] ;
03929 
03930    for( iv=0 ; iv < num_cutouts ; iv++ )
03931       if( w == cutouts[iv]->set_pb ) break ;
03932    if( iv == num_cutouts ) return ;
03933 
03934    typ = cutouts[iv]->type_av->ival ;
03935    switch( typ ){
03936 
03937       default: XBell(dc->display,100) ; return ;  /* action is not defined */
03938 
03939       case CUT_RIGHT_OF:
03940       case CUT_LEFT_OF:      val = im3d->vinfo->xi ; break ;
03941 
03942       case CUT_ANTERIOR_TO:
03943       case CUT_POSTERIOR_TO: val = im3d->vinfo->yj ; break ;
03944 
03945       case CUT_INFERIOR_TO:
03946       case CUT_SUPERIOR_TO:  val = im3d->vinfo->zk ; break ;
03947 
03948       case CUT_TT_ELLIPSOID:{
03949          float x = im3d->vinfo->xi , y = im3d->vinfo->yj , z = im3d->vinfo->zk  ;
03950 
03951          val =  (x-TT_XMID) * (x-TT_XMID) / (TT_XSEMI * TT_XSEMI)
03952               + (y-TT_YMID) * (y-TT_YMID) / (TT_YSEMI * TT_YSEMI)
03953               + (z-TT_ZMID) * (z-TT_ZMID) / (TT_ZSEMI * TT_ZSEMI) ;
03954 
03955          val = 0.1 * rint( 1000.0 * sqrt(val) ) ;  /* round to 1 decimal place */
03956       } break ;
03957 
03958       case CUT_SLANT_XPY_GT:
03959       case CUT_SLANT_XPY_LT:
03960       case CUT_SLANT_XMY_GT:
03961       case CUT_SLANT_XMY_LT:
03962       case CUT_SLANT_YPZ_GT:
03963       case CUT_SLANT_YPZ_LT:
03964       case CUT_SLANT_YMZ_GT:
03965       case CUT_SLANT_YMZ_LT:
03966       case CUT_SLANT_XPZ_GT:
03967       case CUT_SLANT_XPZ_LT:
03968       case CUT_SLANT_XMZ_GT:
03969       case CUT_SLANT_XMZ_LT:{
03970          float x = im3d->vinfo->xi , y = im3d->vinfo->yj , z = im3d->vinfo->zk  ;
03971          int isl = typ - CUT_SLANT_BASE ;
03972 
03973          val =   cut_slant_normals[isl][0] * x
03974                + cut_slant_normals[isl][1] * y
03975                + cut_slant_normals[isl][2] * z ;
03976 
03977          val = 0.1 * rint( 10.0 * val ) ;  /* round to 0.1 mm */
03978       }
03979       break ;
03980    }
03981 
03982    AV_assign_fval( cutouts[iv]->param_av , val ) ;
03983 
03984    if( dynamic_flag && render_handle != NULL ) REND_draw_CB(NULL,NULL,NULL) ;
03985    return ;
03986 }

03874 {
03875    int ii ;
03876 
03877    if( current_cutout_state.opacity_scale != old_cutout_state.opacity_scale ) return 1;
03878 
03879    if( current_cutout_state.num != old_cutout_state.num ) return 1 ;
03880    if( current_cutout_state.num == 0                    ) return 0 ;
03881 
03882    if( current_cutout_state.num > 1 &&
03883        (current_cutout_state.logic != old_cutout_state.logic) ) return 1 ;
03884 
03885    for( ii=0 ; ii < current_cutout_state.num ; ii++ ){
03886       if( current_cutout_state.type[ii] != old_cutout_state.type[ii] ) return 1 ;
03887 
03888       if( current_cutout_state.type[ii] == CUT_NONE ) continue ;
03889 
03890       switch( current_cutout_state.type[ii] ){
03891          default :
03892           if( current_cutout_state.param[ii] != old_cutout_state.param[ii] ) return 1;
03893          break ;
03894 
03895          case CUT_EXPRESSION:
03896           if( strcmp( current_cutout_state.param_str[ii] ,
03897                       old_cutout_state.param_str[ii]      ) != 0 ) return 1 ;
03898 
03899           if( automate_flag &&
03900               strchr(current_cutout_state.param_str[ii],'t') != NULL ) return 1 ;
03901          break ;
03902       }
03903 
03904       if( current_cutout_state.logic != CUTOUT_OR &&
03905           current_cutout_state.num   >  1         &&
03906           current_cutout_state.mustdo[ii] != old_cutout_state.mustdo[ii] ) return 1 ;
03907    }
03908 
03909    return 0 ;
03910 }

03760 {
03761    int iv , val ;
03762    XmString xstr ;
03763    Boolean sens ;
03764 
03765    for( iv=0 ; iv < num_cutouts ; iv++ )
03766       if( av == cutouts[iv]->type_av ) break ;
03767    if( iv == num_cutouts ) return ;
03768 
03769    val = av->ival ;           /* new type */
03770 
03771    HIDE_SCALE ;
03772 
03773    if( val == CUT_NONE ){
03774       XtUnmanageChild( cutouts[iv]->param_lab ) ;
03775       XtUnmanageChild( cutouts[iv]->param_av->wrowcol ) ;
03776       XtUnmanageChild( cutouts[iv]->set_pb ) ;
03777       XtUnmanageChild( cutouts[iv]->mustdo_bbox->wrowcol ) ;
03778    } else {
03779       xstr = XmStringCreateLtoR( cutout_param_labels[val], XmFONTLIST_DEFAULT_TAG ) ;
03780       XtVaSetValues( cutouts[iv]->param_lab , XmNlabelString , xstr , NULL ) ;
03781       XmStringFree(xstr) ;
03782 
03783       XtManageChild( cutouts[iv]->param_lab ) ;
03784       XtManageChild( cutouts[iv]->param_av->wrowcol ) ;
03785       XtManageChild( cutouts[iv]->set_pb ) ;
03786       XtManageChild( cutouts[iv]->mustdo_bbox->wrowcol ) ;
03787 
03788 #undef DESENS
03789 #ifdef DESENS
03790       sens = (val != CUT_EXPRESSION) ;                    /* deactivate */
03791       XtSetSensitive(cutouts[iv]->param_av->wup  ,sens) ; /* if is an   */
03792       XtSetSensitive(cutouts[iv]->param_av->wdown,sens) ; /* Expr > 0   */
03793       XtSetSensitive(cutouts[iv]->set_pb         ,sens) ; /* cutout     */
03794 #else
03795       if( val == CUT_EXPRESSION ){                        /* if Expr > 0 */
03796          XtUnmanageChild( cutouts[iv]->param_av->wup   ); /* expand the  */
03797          XtUnmanageChild( cutouts[iv]->param_av->wdown ); /* size of the */
03798          XtUnmanageChild( cutouts[iv]->set_pb          ); /* text field  */
03799          XtVaSetValues( cutouts[iv]->param_av->wtext ,
03800                            XmNcolumns , AV_NCOL + 9 ,
03801                         NULL ) ;
03802       } else {                                          /* shrink size   */
03803          XtVaSetValues( cutouts[iv]->param_av->wtext ,  /* of text field */
03804                            XmNcolumns , AV_NCOL ,       /* to normal for */
03805                         NULL ) ;                        /* other cutouts */
03806          XtManageChild( cutouts[iv]->param_av->wup   );
03807          XtManageChild( cutouts[iv]->param_av->wdown );
03808          XtManageChild( cutouts[iv]->set_pb          );
03809       }
03810 #endif
03811    }
03812 
03813    FIX_SCALE_SIZE ;
03814    return ;
03815 }

04515 {
04516    if( imseq == NULL ) return ;
04517    drive_MCW_imseq( imseq , isqDR_destroy , NULL ) ;
04518    return ;
04519 }

03420 {
03421    int ax ;
03422    float th , roll,pitch,yaw ;
03423 
03424    /* read angles from arrowval's current status */
03425 
03426    roll  = roll_av ->fval ;
03427    pitch = pitch_av->fval ;
03428    yaw   = yaw_av  ->fval ;
03429 
03430    /* choose axis of rotation based on what was just clicked,
03431     *       and set current angle for that axis to last value (before click) */
03432 
03433         if( av == roll_av  ){ ax = 2; roll  = av->old_fval; }
03434    else if( av == pitch_av ){ ax = 0; pitch = av->old_fval; }
03435    else if( av == yaw_av   ){ ax = 1; yaw   = av->old_fval; }
03436    else
03437         return ;   /* should never happen */
03438 
03439    th = av->fval - av->old_fval ;  /* angle increment */
03440 
03441    roll  *= (PI/180) ;  /* convert to radians */
03442    pitch *= (PI/180) ;
03443    yaw   *= (PI/180) ;
03444    th    *= (PI/180) ;
03445 
03446    /* compute new angles */
03447 
03448    REND_inc_angles( ax, th, &yaw , &pitch, &roll ) ;
03449 
03450    roll  = 0.001 * rint( (180000.0/PI)*roll  ) ;  /* convert to degrees */
03451    pitch = 0.001 * rint( (180000.0/PI)*pitch ) ;  /* (rounded to 1/1000) */
03452    yaw   = 0.001 * rint( (180000.0/PI)*yaw   ) ;
03453 
03454    /* put back into arrowvals */
03455 
03456    AV_assign_fval( roll_av  , roll  ) ; angle_roll  = roll  ;
03457    AV_assign_fval( yaw_av   , yaw   ) ; angle_yaw   = yaw   ;
03458    AV_assign_fval( pitch_av , pitch ) ; angle_pitch = pitch ;
03459 
03460    /* redraw if desirable */
03461 
03462    if( dynamic_flag && render_handle != NULL )
03463       REND_draw_CB(NULL,NULL,NULL) ;
03464 
03465    return ;
03466 }