do{ ppmto_filter = (char **) realloc( ppmto_filter ,                   \
                                        sizeof(char *)*(ppmto_num+1) ) ; \
      ppmto_suffix = (char **) realloc( ppmto_suffix  ,                  \
                                        sizeof(char *)*(ppmto_num+1) ) ; \
      ppmto_bval   = (int *)   realloc( ppmto_bval    ,                  \
                                        sizeof(int)   *(ppmto_num+1) ) ; \
      ppmto_filter[ppmto_num] = (pnam) ;                                 \
      ppmto_suffix[ppmto_num] = (suff) ;                                 \
      ppmto_bval  [ppmto_num] = (bbb)  ; ppmto_num++ ;                   \
      if( dbg ) fprintf(stderr,"IMSAVE: filter '%s' for suffix '%s'\n",  \
                        (pnam) , (suff) ) ;                              \
  } while(0)

do{ if( !AFNI_noenv("AFNI_IMSAVE_WARNINGS") ){                          \
      if( ncant == 0 )                                                   \
       fprintf(stderr,"\n++++++++ IMAGE SAVE SETUP WARNINGS ++++++++\n");\
      fprintf(stderr,                                                    \
              "++ Can't find program %s for Save to %s\n",(nm),(fm)) ;   \
     } ncant++ ;                                                         \
 } while(0)

"Complex-> options control how complex-\n"   \
  "valued images are displayed:\n"             \
  "  ->Mag  == Display magnitude\n"            \
  "  ->Arg  == Display argument (phase)\n"     \
  "  ->Real == Display real part\n"            \
  "  ->Imag == Display imaginary part"

AFNI_CALL_VOID_3ARG( (sq)->status->send_CB ,          \
                       MCW_imseq * , sq ,               \
                       XtPointer   , (sq)->getaux ,     \
                       ISQ_cbs *   , &(cb)          )

do{ char sl[16] ;                                                       \
      if( (seq)->opt.save_filter < 0 ){                                   \
         strcpy(sl, (seq)->opt.save_pnm ? ISQ_save_label_all              \
                                        : ISQ_save_label_bg );            \
      }else{                                                              \
         sprintf(sl,"Save.%.3s",ppmto_suffix[(seq)->opt.save_filter]) ;   \
      }                                                                   \
           if( (seq)->opt.save_agif ) strcpy(sl,"Sav:aGif") ;             \
      else if( (seq)->opt.save_mpeg ) strcpy(sl,"Sav:mpeg") ;             \
      else if( (seq)->opt.save_one  ) sl[3] = '1' ;                       \
      MCW_set_widget_label( (seq)->wbut_bot[NBUT_SAVE] , sl ) ; } while(0)

06552 {
06553 ENTRY("drive_MCW_imseq") ;
06554    if( ! ISQ_VALID(seq) ) RETURN( False );
06555 
06556    switch( drive_code ){
06557 
06558       /*------- error! -------*/
06559 
06560       default:{
06561          fprintf(stderr,"\a\n*** drive_MCW_imseq: code=%d illegal!\n",
06562                  drive_code) ;
06563          XBell( seq->dc->display , 100 ) ;
06564          RETURN( False );
06565       }
06566       break ;
06567 
06568       /*--------- set display range [04 Nov 2003] ----------*/
06569 
06570       case isqDR_setrange:{
06571         float *rng = (float *)drive_data ;
06572         if( rng == NULL ){
06573           seq->rng_bot = seq->rng_top = seq->rng_ztop = 0.0f ;
06574         } else {
06575           seq->rng_bot = rng[0] ; seq->rng_top = rng[1] ; seq->rng_ztop = 0.0 ;
06576         }
06577         ISQ_redisplay( seq , -1 , isqDR_display ) ;
06578         RETURN( True ) ;
06579       }
06580       break ;
06581 
06582       /*--------- save image type? [23 Jan 2003] ----------*/
06583 
06584       case isqDR_setimsave:{
06585         char *suf = (char *)drive_data ;
06586         int ii ;
06587         if( suf == NULL || *suf == '\0' || ppmto_num < 1 ) RETURN(False) ;
06588         for( ii=0 ; ii < ppmto_num ; ii++ ){
06589           if( strcmp(suf  ,ppmto_suffix[ii]) == 0 ) break ;
06590           if( strcmp(suf+1,ppmto_suffix[ii]) == 0 ) break ;
06591         }
06592         if( ii == ppmto_num ) RETURN(False) ;
06593         seq->opt.save_filter = ii ;
06594         SET_SAVE_LABEL(seq) ;
06595         if( seq->num_bbox > 0 && seq->bbox[NTOG_SAV] != NULL )
06596           MCW_set_bbox( seq->bbox[NTOG_SAV] , ppmto_bval[ii] ) ;
06597         RETURN( True ) ;
06598       }
06599       break ;
06600 
06601       /*--------- ignore redraws? [16 Aug 2002] -------------*/
06602 
06603       case isqDR_ignore_redraws:{
06604          int dd = (int)drive_data ;
06605          seq->ignore_redraws = dd ;
06606          RETURN( True ) ;
06607       }
06608       break ;
06609 
06610       /*--------- overlay plot stuff [20 Sep 2001] ----------*/
06611 
06612       case isqDR_plot_label:{
06613          int dd = (int)drive_data ;
06614 
06615          if( dd < 0 ){
06616             INVERT_manage( seq->wbar_label_av->wrowcol ) ;
06617             INVERT_manage( seq->wbar_labsz_av->wrowcol ) ;
06618          } else if( dd != seq->wbar_label_av->ival && dd >= 0 && dd <= 4 ){
06619            AV_assign_ival( seq->wbar_label_av , dd ) ;
06620            ISQ_redisplay( seq , -1 , isqDR_display ) ;
06621          }
06622          RETURN( True ) ;
06623       }
06624 
06625       /*.....................................................*/
06626 
06627       case isqDR_save_jpeg:{                 /* 28 Jul 2005 */
06628         char *fname = (char *)drive_data ;
06629         ISQ_save_jpeg( seq , fname ) ;
06630         RETURN( True ) ;
06631       }
06632 
06633       /*.....................................................*/
06634 
06635       case isqDR_plot_plot:{
06636          int dd = (int)drive_data ;
06637 
06638          if( dd < 0 ){
06639             INVERT_manage( seq->wbar_plots_bbox->wrowcol ) ;
06640          } else {
06641             dd = (dd != 0) ;
06642             if( dd != MCW_val_bbox(seq->wbar_plots_bbox) ){
06643                MCW_set_bbox( seq->wbar_plots_bbox , dd ) ;
06644                ISQ_redisplay( seq , -1 , isqDR_display ) ;
06645             }
06646          }
06647          RETURN( True ) ;
06648       }
06649 
06650       /*--------- record off forever [24 Apr 2001] ----------*/
06651 
06652       case isqDR_record_disable:{
06653          ISQ_remove_widget( seq , seq->record_rc ) ;
06654          seq->record_status = RECORD_STATUS_OFF ;
06655          RETURN( True ) ;
06656       }
06657       break ;
06658 
06659       /*--------- record mode [24 Apr 2001] ----------*/
06660 
06661       case isqDR_record_mode:{
06662          int ii ;
06663          static Pixmap record_pixmap = XmUNSPECIFIED_PIXMAP ;
06664 #define record_width 64
06665 #define record_height 32
06666 static unsigned char record_bits[] = {
06667    0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
06668    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
06669    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x0f, 0x00, 0x00,
06670    0x00, 0x00, 0x00, 0x00, 0x81, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
06671    0x81, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x81, 0x40, 0x00, 0x00,
06672    0x00, 0x00, 0x00, 0x02, 0x81, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
06673    0x81, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x81, 0x40, 0x00, 0x00,
06674    0x00, 0x00, 0x00, 0x02, 0x81, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
06675    0x81, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x81, 0x10, 0x00, 0x00,
06676    0x00, 0x00, 0x00, 0x02, 0x81, 0x1f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
06677    0x81, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0x81, 0x10, 0x00, 0x00,
06678    0x00, 0x00, 0x00, 0x02, 0x81, 0x10, 0x70, 0x00, 0xe0, 0xf0, 0x01, 0x02,
06679    0x81, 0x20, 0x8c, 0xf0, 0x10, 0x21, 0xe2, 0x03, 0x81, 0x20, 0x02, 0x09,
06680    0x09, 0x22, 0x12, 0x02, 0x81, 0x20, 0x02, 0x09, 0x08, 0x22, 0x10, 0x02,
06681    0x81, 0x20, 0xfe, 0x09, 0x08, 0x22, 0x10, 0x02, 0x81, 0x40, 0x02, 0x08,
06682    0x08, 0x22, 0x10, 0x02, 0x81, 0x40, 0x02, 0x08, 0x08, 0x22, 0x10, 0x02,
06683    0x81, 0x40, 0x02, 0x08, 0x08, 0x22, 0x10, 0x02, 0x81, 0x40, 0x02, 0x08,
06684    0x08, 0x22, 0x10, 0x02, 0x81, 0x40, 0x04, 0x11, 0x11, 0x21, 0x20, 0x02,
06685    0x81, 0x40, 0xf8, 0xe0, 0xe0, 0x20, 0xc0, 0x01, 0x01, 0x00, 0x00, 0x00,
06686    0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
06687    0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
06688    0x00, 0x00, 0x00, 0x00};
06689 
06690          if( seq->record_mode ) RETURN( False ) ;  /* already on */
06691          seq->record_mode = 1 ;
06692          seq->cropit = seq->crop_allowed = 0 ;     /* 12 Jun 2002 */
06693 
06694          /* create background pixmap */
06695 
06696          if( record_pixmap == XmUNSPECIFIED_PIXMAP )
06697             record_pixmap = XCreatePixmapFromBitmapData(
06698                               seq->dc->display ,
06699                               RootWindowOfScreen(seq->dc->screen) ,
06700                               record_bits, record_width, record_height ,
06701                               seq->dc->ovc->pixov_brightest ,
06702                               seq->dc->ovc->pixov_darkest ,
06703                               DefaultDepthOfScreen(seq->dc->screen) ) ;
06704 
06705          XtVaSetValues( seq->wform, XmNbackgroundPixmap, record_pixmap, NULL ) ;
06706 
06707          /* disable various widgets */
06708 
06709          ISQ_remove_widget( seq , seq->wbut_bot[NBUT_MONT] ) ;
06710          ISQ_remove_widget( seq , seq->record_rc ) ;
06711          for( ii=0 ; ii < NBUTTON_RIG ; ii++)
06712             ISQ_remove_widget( seq , seq->wbut_rig[ii] ) ;
06713          for( ii=0 ; ii < NARROW-1 ; ii++ ) /* keep "i" arrow */
06714             ISQ_remove_widget( seq , seq->arrow[ii]->wrowcol ) ;
06715          if( seq->ov_opacity_av != NULL ){
06716             ISQ_remove_widget( seq , seq->ov_opacity_sep ) ;
06717             ISQ_remove_widget( seq , seq->ov_opacity_av->wrowcol ) ;
06718          }
06719 
06720          ISQ_remove_widget( seq , seq->zoom_sep ) ;
06721          ISQ_remove_widget( seq , seq->zoom_val_av->wrowcol ) ;
06722          ISQ_remove_widget( seq , seq->zoom_drag_pb ) ;
06723          ISQ_remove_widget( seq , seq->crop_drag_pb ) ;
06724          ISQ_remove_widget( seq , seq->pen_bbox->wrowcol ) ;
06725 
06726          ISQ_remove_widget( seq , seq->arrowpad->wform ) ;
06727          ISQ_remove_widget( seq , seq->wbar ) ;
06728          ISQ_remove_widget( seq , seq->winfo ) ;
06729 
06730          /* change to Save:bkg */
06731 
06732          seq->opt.save_one    = 0 ;
06733          seq->opt.save_agif   = 0 ;   /* 27 Jul 2001 */
06734          seq->opt.save_mpeg   = 0 ;
06735          seq->opt.save_pnm    = 0 ;
06736          seq->opt.save_filter = -1 ;  /* 27 Jun 2001 */
06737          SET_SAVE_LABEL(seq) ;
06738          drive_MCW_imseq( seq , isqDR_setimsave ,
06739                           (XtPointer)getenv("AFNI_DEFAULT_IMSAVE") ) ;
06740 
06741          /* 27 Jun 2001: change help on Save: */
06742 
06743          MCW_unregister_help( seq->wbut_bot[NBUT_DISP] ) ;
06744          if( ppmto_num > 0 ){
06745            MCW_register_help( seq->wbut_bot[NBUT_SAVE] ,
06746                                 "Save controls:\n"
06747                                 " Press with Button 1 (left) to save images\n"
06748                                 " Press with Button 3 (right) to change the\n"
06749                                 "   format of the saved images"
06750                             ) ;
06751            MCW_register_hint( seq->wbut_bot[NBUT_SAVE] ,
06752                               "Button 3 => change save format" ) ;
06753          } else {
06754            MCW_register_help( seq->wbut_bot[NBUT_SAVE] ,
06755                                 "Save controls:\n"
06756                                 " Press with Button 1 (left) to\n"
06757                                 " in the PNM format save images"  ) ;
06758            MCW_register_hint( seq->wbut_bot[NBUT_SAVE] ,
06759                               "Save images as PNM" ) ;
06760          }
06761 
06762          /* change Disp to Kill */
06763 
06764          XtRemoveCallback( seq->wbut_bot[NBUT_DISP] , XmNactivateCallback ,
06765                            ISQ_but_bot_def[NBUT_DISP].func_CB , seq        ) ;
06766 
06767          XtAddCallback( seq->wbut_bot[NBUT_DISP] , XmNactivateCallback ,
06768                         ISQ_record_kill_CB , seq                       ) ;
06769 
06770          MCW_set_widget_label( seq->wbut_bot[NBUT_DISP] , "Kill" ) ;
06771          MCW_unregister_help( seq->wbut_bot[NBUT_DISP] ) ;
06772          MCW_register_hint( seq->wbut_bot[NBUT_DISP] , "Erase current image" ) ;
06773          MCW_register_help( seq->wbut_bot[NBUT_DISP] ,
06774                             "Erase the current image in the recorded sequence.\n"
06775                             "If not later overwritten, this image will NOT\n"
06776                             "be saved when you use Save:bkg to write the image\n"
06777                             "sequence to disk.\n"
06778                            ) ;
06779 
06780          /* attach Done to Save (since Mont is now hidden) */
06781 
06782          XtVaSetValues( seq->wbut_bot[NBUT_DONE] ,
06783                            LEADING_BOT       , XmATTACH_WIDGET          ,
06784                            LEADING_WIDGET_BOT, seq->wbut_bot[NBUT_SAVE] ,
06785                         NULL ) ;
06786 
06787          /* Miscellaneous stuff */
06788 
06789          XtVaSetValues( seq->wtop , XmNtitle , "Image Recorder" , NULL ) ;
06790          if( MCW_isitmwm( seq->wtop ) )
06791             XtVaSetValues( seq->wtop ,
06792                             XmNmwmDecorations, MWM_DECOR_ALL | MWM_DECOR_MAXIMIZE,
06793                            NULL ) ;
06794 
06795          RETURN( True ) ;
06796       }
06797       break ;
06798 
06799       /*--------- opacity button [07 Mar 2001] ----------*/
06800 
06801       case isqDR_opacitybut:{
06802          int val = (int) drive_data ;
06803          if( seq->ov_opacity_av == NULL ) RETURN( False ) ;
06804          if( val == 0 ){
06805             XtUnmanageChild( seq->ov_opacity_sep ) ;
06806             XtUnmanageChild( seq->ov_opacity_av->wrowcol ) ;
06807          }
06808          else {
06809             XtManageChild( seq->ov_opacity_sep ) ;
06810             XtManageChild( seq->ov_opacity_av->wrowcol ) ;
06811          }
06812          RETURN( True ) ;
06813       }
06814       break ;
06815 
06816       /*--------- set opacity value [21 Jan 2003] ----------*/
06817 
06818       case isqDR_setopacity:{
06819         int val = (int) drive_data ;
06820         if( seq->ov_opacity_av == NULL ) RETURN( False ) ;
06821         if( val < OPACITY_BOT || val > OPACITY_TOP ) RETURN( False ) ;
06822         AV_assign_ival( seq->ov_opacity_av , val ) ;
06823         ISQ_opacity_CB( seq->ov_opacity_av , seq ) ;
06824         RETURN( True ) ;
06825       }
06826       break ;
06827 
06828       /*--------- get opacity value [21 Jan 2003] ----------*/
06829 
06830       case isqDR_getopacity:{
06831         int *val = (int *) drive_data ;
06832         if( seq->ov_opacity_av == NULL || val == NULL ) RETURN( False ) ;
06833         *val = seq->ov_opacity_av->ival ;
06834         RETURN( True ) ;
06835       }
06836       break ;
06837 
06838       /*--------- zoom buttons [11 Mar 2002] ----------*/
06839 
06840       case isqDR_zoombut:{
06841          int val = (int) drive_data ;
06842          if( val == 0 ){
06843             XtUnmanageChild( seq->zoom_sep ) ;
06844             XtUnmanageChild( seq->zoom_val_av->wrowcol ) ;
06845             XtUnmanageChild( seq->zoom_drag_pb ) ;
06846             XtUnmanageChild( seq->crop_drag_pb ) ;
06847          } else {
06848             XtManageChild( seq->zoom_sep ) ;
06849             XtManageChild( seq->zoom_val_av->wrowcol ) ;
06850             XtManageChild( seq->zoom_drag_pb ) ;
06851             XtManageChild( seq->crop_drag_pb ) ;
06852          }
06853          RETURN( True ) ;
06854       }
06855       break ;
06856 
06857       /*--------- pen bbox [18 Jul 2003] ----------*/
06858 
06859       case isqDR_penbbox:{
06860          int val = (int) drive_data ;
06861          if( val == 0 )
06862            XtUnmanageChild( seq->pen_bbox->wrowcol ) ;
06863          else
06864            XtManageChild( seq->pen_bbox->wrowcol ) ;
06865          RETURN( True ) ;
06866       }
06867       break ;
06868 
06869       /*--------- set montage [22 Sep 2000] ----------*/
06870       /* [mostly copied from ISQ_montage_action_CB()] */
06871 
06872       case isqDR_setmontage:{
06873          int * mm = (int *) drive_data ;
06874 
06875          if( mm == NULL )                     RETURN( False );  /* sanity */
06876          if( mm[0] < 1 || mm[0] > MONT_NMAX ) RETURN( False );  /* checks */
06877          if( mm[1] < 1 || mm[1] > MONT_NMAX ) RETURN( False );
06878 
06879          seq->mont_nx_old       = seq->mont_nx       ;  /* save */
06880          seq->mont_ny_old       = seq->mont_ny       ;
06881          seq->mont_skip_old     = seq->mont_skip     ;
06882          seq->mont_gap_old      = seq->mont_gap      ;
06883          seq->mont_gapcolor_old = seq->mont_gapcolor ;
06884 
06885          /* set new values, if legal */
06886 
06887          seq->mont_nx = mm[0] ;
06888          seq->mont_ny = mm[1] ;
06889          if( mm[2] >  0 && mm[2] <= MONT_SMAX ) seq->mont_skip     = mm[2]-1 ;
06890          if( mm[3] >= 0 && mm[3] <= MONT_GMAX ) seq->mont_gap      = mm[3] ;
06891          if( mm[4] >= 0 &&
06892              mm[4] <= seq->dc->ovc->ncol_ov-1 ) seq->mont_gapcolor = mm[4] ;
06893 
06894          /* set Save One */
06895 
06896          if( seq->mont_nx * seq->mont_ny > 1 && !seq->opt.save_one ){
06897             seq->opt.save_one  = 1 ;
06898             seq->opt.save_agif = 0 ; /* 27 Jul 2001 */
06899             seq->opt.save_mpeg = 0 ;
06900             SET_SAVE_LABEL(seq) ;
06901          }
06902 
06903          /* now do the redisplay */
06904 
06905          ISQ_redisplay( seq , -1 , isqDR_display ) ;    /* local redraw */
06906 
06907          if( seq->status->send_CB != NULL ){  /* tell AFNI */
06908 
06909             ISQ_cbs cbs ;
06910             THD_ivec3 minf ;
06911             int ijcen = (seq->mont_nx)/2 + (seq->mont_ny/2) * seq->mont_nx ,
06912                 nmont = seq->mont_nx * seq->mont_ny ;
06913 
06914             minf.ijk[0]  = ijcen ;            /* number of slices before center */
06915             minf.ijk[1]  = nmont-ijcen-1 ;    /* number after */
06916             minf.ijk[2]  = seq->mont_skip ;   /* number between slices */
06917             cbs.reason   = isqCR_newmontage ;
06918             cbs.userdata = (XtPointer) &minf ;
06919 
06920             seq->ignore_redraws = 1 ;         /* don't listen to redraws */
06921 #if 0
06922             seq->status->send_CB( seq , seq->getaux , &cbs ) ;
06923 #else
06924             SEND(seq,cbs) ;
06925 #endif
06926             seq->ignore_redraws = 0 ;         /* can listen again */
06927          }
06928 
06929 #if 0
06930          ISQ_redisplay( seq , -1 , isqDR_display ) ;    /* local redraw */
06931 #endif
06932 
06933          RETURN( True );
06934       }
06935       break ;
06936 
06937       /*------- winfo sides text [01 Dec 1999] -------*/
06938 
06939       case isqDR_winfosides:{
06940          char ** ws = (char **) drive_data ;
06941          int iw ;
06942 
06943          if( ws == NULL ){                   /* remove the label data */
06944             seq->winfo_sides[0][0] =
06945              seq->winfo_sides[1][0] =
06946               seq->winfo_sides[2][0] =
06947                seq->winfo_sides[3][0] = '\0' ;
06948 
06949          } else {                           /* change the label data */
06950             for( iw=0 ; iw < 4 ; iw++ ){
06951                if( ws[iw] == NULL || ws[iw][0] == '\0' ){
06952                   seq->winfo_sides[iw][0] = '\0' ;
06953                } else {
06954                   strncpy( seq->winfo_sides[iw] , ws[iw] , 15 ) ;
06955                   seq->winfo_sides[iw][15] = '\0' ;
06956                }
06957             }
06958          }
06959          seq->im_label[0] = '\0' ;  /* will force redraw */
06960          ISQ_draw_winfo( seq ) ;
06961 
06962          if( ws == NULL )                       /* 18 May 2005: add a hint */
06963            MCW_unregister_hint( seq->winfo ) ;  /* for the clueless newbie */
06964          else
06965            MCW_register_hint( seq->winfo ,
06966                     "setenv AFNI_LEFT_IS_LEFT YES disables 'radiology mode'" );
06967 
06968          RETURN( True );
06969       }
06970 
06971       /*------- setifrac [22 Sep 2000] -------*/
06972       /* [mostly copied from ISQ_arrow_CB()]  */
06973 
06974       case isqDR_setifrac:{
06975          float * ff = (float *) drive_data ;
06976 
06977          if( ff == NULL || *ff < FRAC_MIN || *ff > 1.0 ) RETURN( False );
06978 
06979          if( *ff <= FRAC_MAX ){ /* from ISQ_arrow_CB() */
06980             float nfrac = *ff ;
06981             seq->image_frac = nfrac ;
06982 
06983             if( !seq->onoff_state )  /* turn widgets on first, recursively */
06984                drive_MCW_imseq( seq,isqDR_onoffwid,(XtPointer)isqDR_onwid );
06985 
06986             XtVaSetValues( seq->wimage ,
06987                              XmNrightPosition ,(int)(0.49+nfrac*FORM_FRAC_BASE),
06988                              XmNbottomPosition,(int)(0.49+nfrac*FORM_FRAC_BASE),
06989                            NULL ) ;
06990             XtVaSetValues( seq->wscale ,
06991                              XmNrightPosition ,(int)(0.49+nfrac*FORM_FRAC_BASE),
06992                            NULL ) ;
06993             XtVaSetValues( seq->wbar ,
06994                              XmNbottomPosition,(int)(0.49+nfrac*FORM_FRAC_BASE),
06995                            NULL ) ;
06996             XtVaSetValues( seq->winfo ,
06997                              XmNrightPosition ,(int)(0.49+nfrac*FORM_FRAC_BASE),
06998                            NULL ) ;
06999 
07000          } else if( seq->onoff_state ) {  /* turn widgets off */
07001 
07002             drive_MCW_imseq( seq,isqDR_onoffwid,(XtPointer)isqDR_offwid );
07003 
07004          }
07005          RETURN( True );
07006       }
07007       break ;
07008 
07009       /*------- send a simulated key press [18 Feb 2005] -------*/
07010 
07011       case isqDR_keypress:{
07012         unsigned int key = (unsigned int)drive_data ;
07013         (void )ISQ_handle_keypress( seq , key ) ;
07014         RETURN( True );
07015       }
07016       break ;
07017 
07018       /*------- winfo extra text [07 Aug 1999] -------*/
07019 
07020       case isqDR_winfotext:{
07021          char * wt = (char *) drive_data ;
07022 
07023          if( wt == NULL || wt[0] == '\0' ){
07024             seq->winfo_extra[0] = '\0' ;
07025          } else {
07026             strncpy( seq->winfo_extra , wt , 63 ) ;
07027             seq->winfo_extra[63] = '\0' ;
07028          }
07029          seq->im_label[0] = '\0' ;  /* will force redraw */
07030          ISQ_draw_winfo( seq ) ;
07031          RETURN( True );
07032       }
07033 
07034       /*------- button2 stuff -------*/
07035 
07036       case isqDR_button2_pixel:{
07037          seq->button2_pixel = (Pixel) drive_data ;
07038          RETURN( True );
07039       }
07040 
07041       case isqDR_button2_mode:{
07042          seq->button2_drawmode = (int) drive_data ;
07043          RETURN( True );
07044       }
07045 
07046       case isqDR_button2_width:{                  /* 08 Oct 2002 */
07047          seq->button2_width = (int) drive_data ;
07048          RETURN( True );
07049       }
07050 
07051       case isqDR_button2_enable:{
07052          ISQ_timer_stop(seq) ;
07053          if( seq->status->send_CB == NULL ) RETURN( False );  /* makes no sense */
07054          if( seq->button2_enabled )         RETURN( True );   /* already on */
07055 
07056          XtInsertEventHandler(
07057               seq->wimage ,         /* handle events in image */
07058 
07059                0
07060                | ButtonReleaseMask  /* button releases (only #2 is used) */
07061                | Button2MotionMask  /* motion while #2 is down */
07062               ,
07063               FALSE ,               /* nonmaskable events? */
07064               ISQ_button2_EV ,      /* handler routine */
07065               (XtPointer) seq ,     /* client data */
07066               XtListTail            /* last in queue */
07067          ) ;
07068 
07069          seq->button2_enabled = 1 ;
07070          seq->button2_active  = 0 ;
07071 
07072          XtManageChild( seq->pen_bbox->wrowcol ) ;
07073          RETURN( True );
07074       }
07075 
07076       case isqDR_button2_disable:{
07077          if( seq->status->send_CB == NULL ) RETURN( False );  /* makes no sense */
07078          if( !seq->button2_enabled )        RETURN( True );   /* already off */
07079 
07080          XtRemoveEventHandler(
07081               seq->wimage ,         /* unhandle events in image */
07082 
07083                0
07084                | ButtonReleaseMask  /* button releases (only #2 is used) */
07085                | Button2MotionMask  /* motion while #2 is down */
07086               ,
07087               TRUE ,                /* nonmaskable events? */
07088               ISQ_button2_EV ,      /* handler routine */
07089               (XtPointer) seq       /* client data */
07090          ) ;
07091 
07092          seq->button2_enabled = seq->button2_active = 0 ;
07093          ISQ_set_cursor_state( seq , CURSOR_NORMAL ) ;
07094          XtUnmanageChild( seq->pen_bbox->wrowcol ) ;
07095          RETURN( True );
07096       }
07097 
07098       /*------- montage stuff -------*/
07099 
07100       case isqDR_periodicmont:{
07101         int per = ((int) drive_data) != 0 ;
07102 
07103         if( per != seq->mont_periodic ){
07104            seq->mont_periodic = per ;
07105            if( ISQ_REALZ(seq) ) ISQ_redisplay( seq , -1 , isqDR_display ) ;
07106         }
07107         RETURN( True );
07108       }
07109 
07110       case isqDR_sendmontage:{
07111          if( seq->status->send_CB != NULL ){
07112             ISQ_cbs cbs ;
07113             THD_ivec3 minf ;
07114             int ijcen = (seq->mont_nx)/2 + (seq->mont_ny/2) * seq->mont_nx ,
07115                 nmont = seq->mont_nx * seq->mont_ny ;
07116 
07117             minf.ijk[0]  = ijcen ;            /* number of slices before center */
07118             minf.ijk[1]  = nmont-ijcen-1 ;    /* number after */
07119             minf.ijk[2]  = seq->mont_skip ;   /* number between slices */
07120             cbs.reason   = isqCR_newmontage ;
07121             cbs.userdata = (XtPointer) &minf ;
07122 #if 0
07123             seq->status->send_CB( seq , seq->getaux , &cbs ) ;
07124 #else
07125             SEND(seq,cbs) ;
07126 #endif
07127             RETURN( True );
07128          } else {
07129             RETURN( False );
07130          }
07131       }
07132       break ;
07133 
07134       /*------ set icon -----*/
07135 
07136       case isqDR_icon:{
07137          XtVaSetValues( seq->wtop, XmNiconPixmap,(Pixmap)drive_data , NULL ) ;
07138          RETURN( True );
07139       }
07140       break ;
07141 
07142       /*------ set background icon [28 Jan 2004] -------*/
07143 
07144       case isqDR_bgicon:{
07145         XtVaSetValues( seq->wform,
07146                          XmNbackgroundPixmap, (Pixmap)drive_data ,
07147                        NULL ) ;
07148         RETURN( True );
07149       }
07150       break ;
07151 
07152       /*------ get image number -----*/
07153 
07154       case isqDR_getimnr:{
07155          int * retval = (int *) drive_data ;
07156 
07157          if( retval != NULL ) *retval = seq->im_nr ;
07158          RETURN( True );
07159       }
07160       break ;
07161 
07162       /*------ widgets on or off -----*/
07163 
07164       case isqDR_onoffwid:{
07165          int mode = (int) drive_data , turn_on ;
07166          int ww , hh ;
07167 
07168          switch( mode ){
07169             default:
07170             case isqDR_togwid:  turn_on = ! seq->onoff_state ; break ;
07171             case isqDR_onwid:   turn_on = 1                  ; break ;
07172             case isqDR_offwid:  turn_on = 0                  ; break ;
07173          }
07174 
07175          if( turn_on == seq->onoff_state ) RETURN( True );
07176 
07177          MCW_widget_geom( seq->wimage , &ww , &hh , NULL,NULL ) ;
07178 
07179          if( turn_on ){
07180             MCW_manage_widgets( seq->onoff_widgets , seq->onoff_num ) ;
07181             XtVaSetValues(
07182                seq->wimage ,
07183                   XmNrightPosition ,(int)( 0.49+seq->image_frac*FORM_FRAC_BASE ),
07184                   XmNbottomPosition,(int)( 0.49+seq->image_frac*FORM_FRAC_BASE ),
07185                NULL ) ;
07186             XtVaSetValues( seq->wtop ,
07187                               XmNwidth  , (int)(0.49+ww/seq->image_frac) ,
07188                               XmNheight , (int)(0.49+hh/seq->image_frac) ,
07189                            NULL ) ;
07190             if( !seq->button2_enabled ) XtUnmanageChild(seq->pen_bbox->wrowcol);
07191          } else {
07192             MCW_unmanage_widgets( seq->onoff_widgets , seq->onoff_num ) ;
07193             XtVaSetValues( seq->wimage ,
07194                               XmNrightPosition , FORM_FRAC_BASE ,
07195                               XmNbottomPosition, FORM_FRAC_BASE ,
07196                            NULL ) ;
07197             XtVaSetValues( seq->wtop ,
07198                               XmNwidth  , ww ,
07199                               XmNheight , hh ,
07200                            NULL ) ;
07201          }
07202 
07203          seq->onoff_state = turn_on ;
07204          RETURN( True );
07205       }
07206       break ;
07207 
07208       /*------- title --------*/
07209 
07210       case isqDR_title:{
07211          char * title = (char *) drive_data ;
07212 
07213          if( title == NULL || strlen(title) == 0 ) title = "AFNI" ;
07214 
07215          XtVaSetValues( seq->wtop , XmNtitle , title , NULL ) ;
07216 #if 1
07217          if( MCW_isitmwm( seq->wtop ) )
07218             XtVaSetValues( seq->wtop ,
07219                             XmNmwmDecorations, MWM_DECOR_ALL | MWM_DECOR_MAXIMIZE,
07220                            NULL ) ;
07221 #endif
07222          RETURN( True );
07223       }
07224       break ;
07225 
07226       /*------- death! -------*/
07227 
07228       case isqDR_destroy:{
07229          ISQ_timer_stop(seq) ;
07230          ISQ_but_done_CB( NULL , (XtPointer) seq , NULL ) ;
07231          RETURN( True );
07232       }
07233       break ;
07234 
07235       /*------- unrealize! -------*/
07236 
07237       case isqDR_unrealize:{
07238          ISQ_timer_stop(seq) ;
07239          if( ISQ_REALZ(seq) ) XtUnrealizeWidget( seq->wtop ) ;
07240          seq->valid = 1 ;
07241          RETURN( True );
07242       }
07243       break ;
07244 
07245       /*------- realize! -------*/
07246 
07247       case isqDR_realize:{
07248          if( ! ISQ_REALZ(seq) ){
07249             XtRealizeWidget( seq->wtop ) ;
07250             WAIT_for_window( seq->wtop ) ;
07251             NORMAL_cursorize( seq->wtop ) ;
07252             POPUP_cursorize( seq->wimage ) ;
07253             POPUP_cursorize( seq->wbar ) ;
07254             POPUP_cursorize( seq->wbut_bot[NBUT_SAVE] ) ;
07255             XmUpdateDisplay( seq->wtop ) ;
07256          }
07257 #ifndef DONT_ONOFF_ONE
07258          if( seq->status->num_total == 1 )  /* 08 Aug 2001 */
07259             drive_MCW_imseq( seq , isqDR_onoffwid , (XtPointer) isqDR_offwid ) ;
07260 #endif
07261          seq->valid = 2 ;
07262          RETURN( True );
07263       }
07264       break ;
07265 
07266       /*------- change helptext! -------*/
07267 
07268       case isqDR_imhelptext:{
07269         char * newtxt = (char *) drive_data ;
07270         int ii ;
07271 
07272         if( newtxt == NULL ) RETURN( False );
07273         ii = strlen(newtxt) ;
07274         if( ii == 0 ) RETURN( False );
07275 
07276         strncpy( seq->im_helptext , newtxt , ISQ_NHELP ) ;
07277         seq->im_helptext[ISQ_NHELP] = '\0' ;
07278         RETURN( True );
07279       }
07280       break ;
07281 
07282       /*------- display anew! -------*/
07283 
07284       case isqDR_reimage:
07285       case isqDR_reshow:
07286       case isqDR_overlay:
07287       case isqDR_display:{
07288          int n = (int) drive_data ;
07289 
07290          if( ! seq->ignore_redraws )
07291             ISQ_redisplay( seq , n , drive_code ) ;
07292          RETURN( True );
07293       }
07294       break ;
07295 
07296       /*------- display bar anew [23 Aug 1998] -------*/
07297 
07298       case isqDR_rebar:{
07299          KILL_2XIM( seq->given_xbar , seq->sized_xbar ) ; /* destroy old */
07300          if( seq->onoff_state ) ISQ_show_bar( seq ) ;     /* show new?  */
07301          RETURN( True );
07302       }
07303       break ;
07304 
07305       /*------- new cursor for image -------*/
07306 
07307       case isqDR_cursor:{
07308          int cur = (int) drive_data ;
07309 
07310          MCW_alter_widget_cursor( seq->wimage , cur , "yellow" , "blue" ) ;
07311          RETURN( True );
07312       }
07313       break ;
07314 
07315       /*------- new options -------*/
07316 
07317       case isqDR_options:{
07318          ISQ_options * newopt = (ISQ_options *) drive_data ;
07319          int sf ;
07320 
07321          if( ppmto_num > 0 )           /* 27 Mar 2002: keep the old */
07322            sf = seq->opt.save_filter ; /*              save filter  */
07323 
07324          if( newopt != NULL ) seq->opt = *newopt ;
07325 
07326          if( ppmto_num > 0 )
07327            seq->opt.save_filter = sf ;
07328 
07329          seq->opt.parent = (XtPointer) seq ;
07330          SET_SAVE_LABEL(seq) ;
07331          AV_SENSITIZE(seq->ov_opacity_av,!seq->opt.no_overlay) ; /* 09 Mar 2001 */
07332 
07333 
07334          seq->im_label[0] = '\0' ;  /* will force redraw */
07335          if( ISQ_REALZ(seq) ) ISQ_redisplay( seq , -1 , isqDR_display ) ;
07336          RETURN( True );
07337       }
07338       break ;
07339 
07340       /*------- get current options [07 Aug 1999] -------*/
07341 
07342       case isqDR_getoptions:{
07343          ISQ_options * opt = (ISQ_options *) drive_data ;
07344 
07345          if( opt == NULL ) RETURN( False );
07346          *opt = seq->opt ;
07347          RETURN( True );
07348       }
07349 
07350       /*------- turn arrowpad on -------*/
07351 
07352       case isqDR_arrowpadon:{
07353          char * helptext = (char *) drive_data ;
07354 
07355          XtSetMappedWhenManaged( seq->arrowpad->wform , True ); /* on */
07356 
07357          if( helptext != NULL && strlen(helptext) > 0 ){
07358             char * str = XtNewString( helptext ) ;
07359             MCW_reghelp_children( seq->arrowpad->wform , str ) ;
07360             XtFree(str) ;  /* 28 Sep 1998: via Purify */
07361          }
07362          RETURN( True );
07363       }
07364       break ;
07365 
07366       case isqDR_arrowpadhint:{
07367          int ib ;
07368          char ** hint = (char **) drive_data ;
07369          if( hint == NULL ) RETURN( False );
07370          for( ib=0 ; ib < 5 ; ib++ )
07371             MCW_register_hint( seq->arrowpad->wbut[ib] , hint[ib] ) ;
07372          RETURN( True );
07373       }
07374       break ;
07375 
07376       /*------- turn arrowpad off -------*/
07377 
07378       case isqDR_arrowpadoff:{
07379          XtSetMappedWhenManaged( seq->arrowpad->wform , False ); /* off */
07380          RETURN( True );
07381       }
07382       break ;
07383 
07384       /*------- new numtotal -------*/
07385 
07386 #if 0                                   /* 29 Jul 2002: removed from the canon for unuse */
07387       case isqDR_numtotal:{
07388          int newtot = (int) drive_data ,
07389              oldtot = seq->status->num_total ,
07390              numser = seq->status->num_series , ii ;
07391          char * msg =
07392              "illegal change to image\n"
07393              "count from driver routine\n"
07394              "(press here to continue)" ;
07395 
07396          /* check for error conditions */
07397 
07398          if( newtot == oldtot ) RETURN( True );
07399 
07400          if( newtot < 2 || newtot < numser ){
07401             if( ISQ_REALZ(seq) )
07402                MCW_popup_message( seq->wimage , msg , MCW_USER_KILL ) ;
07403             fprintf(stderr,"\n%s\n",msg) ;
07404             RETURN( False );
07405          }
07406 
07407          /* stop the automatic statistics calculations, if started */
07408 
07409          if( seq->glstat->worker != 0 ){
07410             XtRemoveWorkProc( seq->glstat->worker ) ;
07411             seq->glstat->worker = 0 ;
07412          }
07413 
07414          /* setup new space for the per image statistics */
07415 
07416          seq->imstat = (ISQ_indiv_statistics *)
07417                         XtRealloc( (char *) seq->imstat ,
07418                                    sizeof(ISQ_indiv_statistics) * newtot ) ;
07419 
07420          for( ii=oldtot ; ii < newtot ; ii++ )
07421              seq->imstat[ii].one_done = seq->imstat[ii].glob_done = False ;
07422 
07423          /* let the imseq know that the number of images is different */
07424 
07425          seq->status->num_total = newtot ;
07426 
07427          XtVaSetValues( seq->wscale ,
07428                            XmNmaximum , newtot-1 ,
07429                         NULL ) ;
07430 
07431          if( seq->im_nr >= newtot )
07432             ISQ_redisplay( seq , newtot-1 , isqDR_display ) ;
07433 
07434          RETURN( True );
07435       }
07436       break ;
07437 #endif
07438 
07439       /*------- new image sequence!!! -------*/
07440 
07441       case isqDR_newseq:{
07442          Boolean good ;
07443          ISQ_timer_stop(seq) ;
07444          good = ISQ_setup_new( seq , drive_data ) ;
07445          RETURN( good );
07446       }
07447       break ;
07448 
07449       /*------ re-initialize image statistics -----*/
07450 
07451       case isqDR_clearstat:{
07452          int ii ;
07453 
07454          seq->opt.scale_group = ISQ_SCL_AUTO ;  /* autoscaling */
07455          ISQ_disp_options( seq , False ) ;      /* set buttons */
07456 
07457          if( seq->glstat->worker != 0 ){  /* remove work process */
07458             XtRemoveWorkProc( seq->glstat->worker ) ;
07459             seq->glstat->worker = 0 ;
07460          }
07461 
07462          for( ii=0 ; ii < seq->status->num_total ; ii++ )
07463             seq->imstat[ii].one_done = seq->imstat[ii].glob_done = False ;
07464 
07465          for( ii=0 ; ii < NHISTOG ; ii++ )
07466             seq->glstat->hist[ii] = 0 ;  /* initialize histogram */
07467 
07468          seq->glstat->mm_done =
07469            seq->glstat->per_done = (seq->status->num_series < 2 ) ;
07470 
07471 #ifdef AUTOMATE_STATISTICS
07472          if( seq->glstat->mm_done ){
07473             seq->glstat->worker = 0 ;
07474          } else {
07475             seq->glstat->worker = XtAppAddWorkProc(
07476                                         seq->dc->appcontext ,
07477                                         ISQ_statistics_WP , seq ) ;
07478          }
07479 #else
07480          seq->glstat->worker = 0 ;
07481 #endif
07482       }
07483       break ;
07484 
07485    }  /* end of switch on drive_code */
07486 
07487    RETURN( False );  /* should never be reached! */
07488 }

02077 {
02078    float hh,vv , mh,dh , hhold,vvold ;
02079 
02080 ENTRY("ISQ_actually_pan") ;
02081 
02082    if( !ISQ_REALZ(seq) || seq->zoom_fac == 1 || seq->zoom_xim == NULL ) EXRETURN;
02083 
02084    mh = (seq->zoom_fac-1.001)/seq->zoom_fac ;  /* max offset    */
02085    dh = 0.020/seq->zoom_fac ;                  /* delta offset   */
02086    hh=seq->zoom_hor_off ; hhold=hh ;           /* current offsets */
02087    vv=seq->zoom_ver_off ; vvold=vv ;
02088 
02089    hh += lr*dh ;
02090         if( hh < 0.0) hh = 0.0 ;
02091    else if( hh > mh ) hh = mh  ;
02092 
02093    vv += ud*dh ;
02094         if( vv < 0.0) vv = 0.0 ;
02095    else if( vv > mh ) vv = mh  ;
02096 
02097    if( vv == vvold && hh == hhold ) EXRETURN ; /* no changes? */
02098 
02099    seq->zoom_hor_off = hh ;                    /* changes! */
02100    seq->zoom_ver_off = vv ;
02101    ISQ_show_zoom( seq ) ;                      /* redraw */
02102    EXRETURN ;
02103 }

06323 {
06324    MCW_imseq * seq = (MCW_imseq *) client_data ;
06325    int ddd ;
06326 
06327 ENTRY("ISQ_arrow_CB") ;
06328 
06329    if( ! ISQ_REALZ(seq) ) EXRETURN ;
06330 
06331    if( av->fval > av->old_fval ) ddd = -1 ;
06332    else                          ddd =  1 ;
06333 
06334 /*
06335    ddd = (av->fval > av->old_fval) ? (-1) : (1) ;
06336 */
06337 
06338    if( av == seq->arrow[NARR_SQUEEZE] ){
06339            DC_palette_squeeze( seq->dc , ddd ) ;
06340            COLORMAP_CHANGE(seq) ;      /* 22 Aug 1998 */
06341 
06342    } else if( av == seq->arrow[NARR_BRIGHT]  ){
06343            DC_palette_bright(  seq->dc , ddd ) ;
06344            COLORMAP_CHANGE(seq) ;      /* 22 Aug 1998 */
06345 
06346    } else if( av == seq->arrow[NARR_ROTATE]  ){
06347            DC_palette_rotate(  seq->dc ,-ddd ) ;
06348            COLORMAP_CHANGE(seq) ;      /* 22 Aug 1998 */
06349 
06350    } else if( av == seq->arrow[NARR_GAMMA]   ){
06351            if( seq->imim == NULL || seq->imim->kind != MRI_rgb ){
06352              double new_gamma = seq->dc->gamma ;
06353              if( ddd > 0 ) new_gamma *= 0.95 ;
06354              else          new_gamma /= 0.95 ;
06355              DC_palette_restore( seq->dc , new_gamma ) ;
06356              COLORMAP_CHANGE(seq) ;      /* 22 Aug 1998 */
06357 
06358            } else {   /* 25 Apr 2005: delta gamma on RGB images */
06359              if( ddd > 0 ) seq->rgb_gamma *= 0.95 ;
06360              else          seq->rgb_gamma /= 0.95 ;
06361              ISQ_redisplay( seq , -1 , isqDR_reimage ) ;
06362            }
06363 
06364    } else if( av == seq->arrow[NARR_FRAC]  ){  /* 25 Oct 1996 */
06365       float nfrac = seq->image_frac ;
06366 
06367       nfrac += (ddd < 0) ? DFRAC : -DFRAC ;
06368 
06369       if( nfrac >= FRAC_MIN && nfrac <= FRAC_MAX ){
06370          seq->image_frac = nfrac ;
06371 
06372          XtVaSetValues( seq->wimage ,
06373                           XmNrightPosition ,(int)(0.49 + nfrac * FORM_FRAC_BASE),
06374                           XmNbottomPosition,(int)(0.49 + nfrac * FORM_FRAC_BASE),
06375                         NULL ) ;
06376          XtVaSetValues( seq->wscale ,
06377                           XmNrightPosition ,(int)(0.49 + nfrac * FORM_FRAC_BASE),
06378                         NULL ) ;
06379          XtVaSetValues( seq->wbar ,
06380                           XmNbottomPosition,(int)(0.49 + nfrac * FORM_FRAC_BASE),
06381                         NULL ) ;
06382          XtVaSetValues( seq->winfo ,
06383                           XmNrightPosition ,(int)(0.49 + nfrac * FORM_FRAC_BASE),
06384                         NULL ) ;
06385       } else {
06386          XBell( seq->dc->display , 100 ) ;
06387       }
06388    }
06389 
06390    ISQ_but_done_reset( seq ) ;
06391    EXRETURN ;
06392 }

07496 {
07497    MCW_imseq * seq = (MCW_imseq *) client_data ;
07498 
07499    ISQ_cbs cbs ;
07500    int xorg,yorg , xwin,ywin , xoff,yoff ;
07501 
07502 ENTRY("ISQ_arrowpad_CB") ;
07503 
07504    if( ! ISQ_REALZ(seq) || seq->status->send_CB == NULL ) EXRETURN ;
07505 
07506    cbs.event = &(apad->xev) ;  /* copy event for user's edification */
07507 
07508    if( apad->which_pressed == AP_MID ){
07509       cbs.reason = isqCR_appress ;
07510 #if 0
07511       seq->status->send_CB( seq , seq->getaux , &cbs ) ;
07512 #else
07513       SEND(seq,cbs) ;
07514 #endif
07515       EXRETURN ;
07516    }
07517 
07518    /* 24 Jan 2003: pan a zoomed image */
07519 
07520    if( seq->zoom_button1 && seq->zoom_fac > 1 && seq->zoom_xim != NULL ){
07521      switch( apad->which_pressed ){
07522        default:
07523        case AP_DOWN:  xoff =  0 ; yoff = -1 ; break ;
07524        case AP_UP:    xoff =  0 ; yoff =  1 ; break ;
07525        case AP_LEFT:  xoff =  1 ; yoff =  0 ; break ;
07526        case AP_RIGHT: xoff = -1 ; yoff =  0 ; break ;
07527      }
07528      ISQ_actually_pan( seq , xoff , yoff ) ;
07529      EXRETURN ;
07530    }
07531 
07532    xwin = ywin = XYORG ;
07533 
07534    switch( apad->which_pressed ){
07535       default:
07536       case AP_DOWN:  ywin = XYORG + DXY ; break ;
07537       case AP_UP:    ywin = XYORG - DXY ; break ;
07538       case AP_LEFT:  xwin = XYORG - DXY ; break ;
07539       case AP_RIGHT: xwin = XYORG + DXY ; break ;
07540    }
07541 
07542    xorg = yorg = XYORG ;       ISQ_flipxy( seq , &xorg,&yorg ) ;
07543    xoff = xwin ; yoff = ywin ; ISQ_flipxy( seq , &xoff,&yoff ) ;
07544 
07545         if( xoff > xorg ) cbs.reason = isqCR_dxplus  ;
07546    else if( xoff < xorg ) cbs.reason = isqCR_dxminus ;
07547    else if( yoff > yorg ) cbs.reason = isqCR_dyplus  ;
07548    else if( yoff < yorg ) cbs.reason = isqCR_dyminus ;
07549    else                   EXRETURN ;                     /* error! */
07550 
07551 #if 0
07552    seq->status->send_CB( seq , seq->getaux , &cbs ) ;
07553 #else
07554    SEND(seq,cbs) ;
07555 #endif
07556    EXRETURN ;
07557 }

06399 {
06400    MCW_imseq *seq = (MCW_imseq *) client_data ;
06401 
06402 ENTRY("ISQ_but_cnorm_CB") ;
06403 
06404    if( ! ISQ_REALZ(seq) ) EXRETURN ;
06405 
06406    DC_palette_restore( seq->dc , 0.0 ) ;
06407    seq->rgb_gamma  = 1.0 ;     /* 25 Apr 2005 */
06408    seq->rgb_offset = 0.0 ;
06409    COLORMAP_CHANGE(seq) ;      /* 22 Aug 1998 */
06410    ISQ_but_done_reset( seq ) ;
06411    EXRETURN ;
06412 }

03044 {
03045    MCW_imseq *seq = (MCW_imseq *) client_data ;
03046 
03047 ENTRY("ISQ_but_color_CB") ;
03048 
03049    if( ! ISQ_REALZ(seq) ) EXRETURN ;
03050 
03051    if( seq->dc->use_xcol_im ) DC_palette_setgray( seq->dc ) ;
03052    else                       DC_palette_setcolor( seq->dc ) ;
03053 
03054    COLORMAP_CHANGE(seq) ;      /* 22 Aug 1998 */
03055    ISQ_but_done_reset( seq ) ;
03056    EXRETURN ;
03057 }

03063 {
03064    MCW_imseq *seq = (MCW_imseq *) client_data ;
03065 
03066 ENTRY("ISQ_but_cswap_CB") ;
03067 
03068    if( ! ISQ_REALZ(seq) ) EXRETURN ;
03069 
03070    DC_palette_swap( seq->dc ) ;
03071    COLORMAP_CHANGE(seq) ;      /* 22 Aug 1998 */
03072    ISQ_but_done_reset( seq ) ;
03073    EXRETURN ;
03074 }

05405 {
05406    MCW_imseq *seq = (MCW_imseq *) client_data ;
05407    int ib ;
05408    Widget rctop , rcboxes , shtop ;
05409    Widget swtop=NULL ;
05410 
05411 ENTRY("ISQ_but_disp_CB") ;
05412 
05413    if( ! ISQ_REALZ(seq) || seq->dialog != NULL ) EXRETURN ;
05414 
05415    for( ib=0 ; ib < NBUTTON_BOT-1 ; ib++ )        /* turn off buttons  */
05416       if( ISQ_but_bot_dial[ib] == True )          /* that also want to */
05417         SENSITIZE( seq->wbut_bot[ib] , False ) ;  /* use seq->dialog   */
05418 
05419    seq->dialog = XtVaCreatePopupShell(
05420                     "menu" , xmDialogShellWidgetClass , seq->wtop ,
05421                        XmNtitle , "Display Options" ,
05422                        XmNdeleteResponse , XmDO_NOTHING ,
05423                        XmNinitialResourcesPersistent , False ,
05424                     NULL ) ;
05425 
05426    SAVEUNDERIZE(seq->dialog) ; /* 27 Feb 2001 */
05427 
05428    DC_yokify( seq->dialog , seq->dc ) ;  /* 14 Sep 1998 */
05429 
05430    seq->dialog_starter = NBUT_DISP ;
05431 
05432 #if 1
05433    if( MCW_isitmwm(w) )
05434       XtVaSetValues( seq->dialog ,
05435                        XmNmwmDecorations , MWM_DECOR_BORDER ,
05436                        XmNmwmFunctions ,   MWM_FUNC_MOVE
05437                                          | MWM_FUNC_CLOSE ,
05438                      NULL ) ;
05439 #endif
05440 
05441    XmAddWMProtocolCallback(           /* make "Close" window menu work */
05442            seq->dialog ,
05443            XmInternAtom( seq->dc->display , "WM_DELETE_WINDOW" , False ) ,
05444            ISQ_disp_act_CB , seq ) ;
05445 
05446    for( ib=0 ; ib < NACT_DISP ; ib++ )
05447       ISQ_disp_act[ib].data = (XtPointer) seq ;
05448 
05449    if( seq->dc->height < 1024 ||               /* 21 Jun 2005 */
05450        AFNI_yesenv("AFNI_DISP_SCROLLBARS") ){  /* 31 Jan 2002 */
05451 
05452       shtop = swtop = XtVaCreateManagedWidget(
05453                  "menu" , xmScrolledWindowWidgetClass , seq->dialog ,
05454                     XmNscrollingPolicy        , XmAUTOMATIC ,
05455                     XmNvisualPolicy           , XmVARIABLE ,
05456                     XmNscrollBarDisplayPolicy , XmSTATIC ,
05457                     XmNinitialResourcesPersistent , False ,
05458                  NULL ) ;
05459    } else {
05460       shtop = seq->dialog ;
05461    }
05462 
05463    rctop = XtVaCreateWidget(
05464               "menu" , xmRowColumnWidgetClass , shtop ,
05465                  XmNpacking    , XmPACK_TIGHT ,
05466                  XmNnumColumns , 1 ,
05467 
05468                  XmNinitialResourcesPersistent , False ,
05469               NULL ) ;
05470 
05471    rcboxes = XtVaCreateWidget(
05472                 "menu" , xmRowColumnWidgetClass , rctop ,
05473                    XmNpacking    , XmPACK_TIGHT ,
05474                    XmNnumColumns , 2 ,
05475 
05476                    XmNinitialResourcesPersistent , False ,
05477               NULL ) ;
05478 
05479    for( ib=0 ; ib < NBOX_DISP ; ib++ ){
05480       int jh ;
05481       char ** bbh = ISQ_bb_allhelp[ib] ;
05482       char ** cch = ISQ_bb_allhint[ib] ;
05483 
05484       /*** 30 Oct 1996: transformations just above the IMPROC buttons ***/
05485 
05486       if( ib == NTOG_IMP ){
05487          int nav = 0 ;
05488 
05489          /*---- FIRST, add some check boxes for special options ----*/
05490 
05491          char *save_one_label[] = { "Save One" }  ; /* 26 Jul 2001 */
05492          char *save_agif_label  = "Save Anim GIF" ; /* 27 Jul 2001 */
05493          char *save_mpeg_label  = "Save Anim MPG" ; /* 02 Aug 2001 */
05494          char *save_anim_label[2] ;
05495 
05496          seq->save_one_bbox = new_MCW_bbox( rcboxes ,
05497                                             1 ,
05498                                             save_one_label ,
05499                                             MCW_BB_check ,
05500                                             MCW_BB_frame ,
05501                                             ISQ_disp_act_CB , (XtPointer) seq ) ;
05502          MCW_reghelp_children( seq->save_one_bbox->wrowcol ,
05503                                " \n"
05504                                "When pressed IN, then the 'Save' button\n"
05505                                "will only save a snapshot of the current\n"
05506                                "display.  This is the ONLY way to save\n"
05507                                "a montage.\n"
05508                                "\n"
05509                                "When pressed OUT, then the 'Save' button\n"
05510                                "asks for the first and last image indexes\n"
05511                                "to save, and then saves each individual\n"
05512                                "image (no montage) to a file.\n"
05513                              ) ;
05514          MCW_reghint_children( seq->save_one_bbox->wrowcol ,
05515                                "Save just 1 (including montage)" ) ;
05516 
05517          if( ppmto_agif_filter != NULL || ppmto_mpeg_filter != NULL ){
05518            int nb = 0 ;
05519            if( ppmto_agif_filter != NULL ) save_anim_label[nb++]=save_agif_label;
05520            if( ppmto_mpeg_filter != NULL ) save_anim_label[nb++]=save_mpeg_label;
05521            seq->save_agif_bbox = new_MCW_bbox( rcboxes ,
05522                                                nb ,
05523                                                save_anim_label ,
05524                                                MCW_BB_radio_zero ,
05525                                                MCW_BB_frame ,
05526                                                ISQ_disp_act_CB, (XtPointer)seq );
05527            MCW_reghelp_children( seq->save_agif_bbox->wrowcol ,
05528                                  " \n"
05529                                  "Controls if image sequence is saved to\n"
05530                                  "an animation file, rather than a bunch\n"
05531                                  "of separate image files.\n"
05532                                  "* This takes precedence over 'Save One',\n"
05533                                  "    if it is also turned on.\n"
05534                                  "* GIF animations require gifsicle.\n"
05535                                  "* MPEG-1 animations require mpeg_encode.\n"
05536                                ) ;
05537            MCW_reghint_children( seq->save_agif_bbox->wrowcol ,
05538                                  "Save image sequence to animation" ) ;
05539          } else {
05540            seq->save_agif_bbox = NULL ;
05541          }
05542 
05543          /*---- OK, do the transforms NOW ----*/
05544 
05545          if( seq->status->slice_proj != NULL &&
05546              seq->status->slice_proj->num > 0  ){  /* 31 Jan 2002 */
05547 
05548              (void) XtVaCreateManagedWidget(
05549                       "menu" , xmSeparatorWidgetClass , rcboxes ,
05550                          XmNseparatorType , XmSINGLE_LINE ,
05551                          XmNinitialResourcesPersistent , False ,
05552                       NULL ) ;
05553 
05554              seq->slice_proj_av =
05555                 new_MCW_optmenu( rcboxes , "Project" ,
05556                                  0 , seq->status->slice_proj->num ,
05557                                  seq->slice_proj_index , 0 ,
05558                                  ISQ_slice_proj_CB , (XtPointer) seq ,
05559                                  ISQ_transform_label ,
05560                                  (XtPointer) seq->status->slice_proj ) ;
05561 
05562              if( seq->status->slice_proj->num >= COLSIZE )
05563                 AVOPT_columnize( seq->slice_proj_av ,
05564                                  (seq->status->slice_proj->num/COLSIZE)+1 ) ;
05565 
05566              MCW_reghelp_children( seq->slice_proj_av->wrowcol ,
05567                                    "Choose a projection function\n"
05568                                    "to apply to plus-or-minus\n"
05569                                    "'Slab' images from each pixel.\n"
05570                                    "Built-in projections:\n"
05571                                    " Minimum = smallest value in slab\n"
05572                                    " Maximum = largest value in slab\n"
05573                                    " Mean    = average value in slab\n"
05574                                    " Median  = median value in slab\n"
05575                                    " Extreme = value farthest from median" ) ;
05576 
05577              MCW_reghint_children( seq->slice_proj_av->wrowcol ,
05578                                    "Image projection function"  ) ;
05579 
05580              seq->slice_proj_range_av =
05581                 new_MCW_optmenu( rcboxes , "Slab +-" ,
05582                                  0 , 19 , seq->slice_proj_range , 0 ,
05583                                  ISQ_slice_proj_CB , (XtPointer) seq ,
05584                                  NULL , NULL ) ;
05585              MCW_reghelp_children( seq->slice_proj_range_av->wrowcol ,
05586                                    "Choose thickness of Project slice\n"
05587                                    "package (in each direction from\n"
05588                                    "central slice).  For example:\n"
05589                                    " 2 ==> slab is 5 images thick\n"
05590                                    "       (2 before, 2 after, central)" ) ;
05591              MCW_reghint_children( seq->slice_proj_range_av->wrowcol ,
05592                                    "Slab half-thickness"              ) ;
05593              nav++ ;
05594          }
05595 
05596          /* 0D transforms */
05597 
05598          if( seq->status->transforms0D != NULL &&
05599              seq->status->transforms0D->num > 0  ){
05600 
05601              (void) XtVaCreateManagedWidget(
05602                       "menu" , xmSeparatorWidgetClass , rcboxes ,
05603                          XmNseparatorType , XmSINGLE_LINE ,
05604                          XmNinitialResourcesPersistent , False ,
05605                       NULL ) ;
05606 
05607              seq->transform0D_av =
05608                 new_MCW_optmenu( rcboxes , "Tran 0D" ,
05609                                  0 , seq->status->transforms0D->num ,
05610                                  seq->transform0D_index , 0 ,
05611                                  ISQ_transform_CB , (XtPointer) seq ,
05612                                  ISQ_transform_label ,
05613                                  (XtPointer) seq->status->transforms0D ) ;
05614 
05615              if( seq->status->transforms0D->num >= COLSIZE )
05616                 AVOPT_columnize( seq->transform0D_av ,
05617                                  (seq->status->transforms0D->num/COLSIZE)+1 ) ;
05618 
05619              MCW_reghelp_children( seq->transform0D_av->wrowcol ,
05620                                    "Choose a function to apply to\n"
05621                                    "each point in the image." ) ;
05622              MCW_reghint_children( seq->transform0D_av->wrowcol ,
05623                                    "Pointwise transformations" ) ;
05624              nav++ ;
05625          }
05626 
05627          /* 2D transforms */
05628 
05629          if( seq->status->transforms2D != NULL &&
05630              seq->status->transforms2D->num > 0  ){
05631 
05632              (void) XtVaCreateManagedWidget(
05633                       "menu" , xmSeparatorWidgetClass , rcboxes ,
05634                          XmNseparatorType , XmSINGLE_LINE ,
05635                          XmNinitialResourcesPersistent , False ,
05636                       NULL ) ;
05637 
05638              seq->transform2D_av =
05639                 new_MCW_optmenu( rcboxes , "Tran 2D" ,
05640                                  0 , seq->status->transforms2D->num ,
05641                                  seq->transform2D_index , 0 ,
05642                                  ISQ_transform_CB , (XtPointer) seq ,
05643                                  ISQ_transform_label ,
05644                                  (XtPointer) seq->status->transforms2D ) ;
05645 
05646              if( seq->status->transforms2D->num >= COLSIZE )
05647                 AVOPT_columnize( seq->transform2D_av ,
05648                                  (seq->status->transforms2D->num/COLSIZE)+1 ) ;
05649 
05650              MCW_reghelp_children( seq->transform2D_av->wrowcol ,
05651                                    "Choose a function to apply to\n"
05652                                    "the underlay image as a whole." ) ;
05653              MCW_reghint_children( seq->transform2D_av->wrowcol ,
05654                                    "Global transformations" ) ;
05655              nav++ ;
05656          }
05657 
05658          /* 30 Dec 1998: rowgraphs */
05659 
05660          if( nav > 0 && seq->status->send_CB != NULL ){
05661             (void) XtVaCreateManagedWidget(
05662                      "menu" , xmSeparatorWidgetClass , rcboxes ,
05663                         XmNseparatorType , XmSINGLE_LINE ,
05664                         XmNinitialResourcesPersistent , False ,
05665                      NULL ) ;
05666 
05667             seq->rowgraph_av =
05668                new_MCW_optmenu( rcboxes , "RowGraphs" ,
05669                                 0 , ROWGRAPH_MAX , seq->rowgraph_num , 0 ,
05670                                 ISQ_rowgraph_CB , (XtPointer) seq ,
05671                                 ISQ_rowgraph_label , NULL ) ;
05672             AVOPT_columnize( seq->rowgraph_av , 2 ) ;
05673 
05674             MCW_reghelp_children( seq->rowgraph_av->wrowcol ,
05675                                   "Rowgraphs are plots of the underlay\n"
05676                                   "(grayscale) image intensity as\n"
05677                                   "x vs. y graphs.  Each graph is from\n"
05678                                   "one displayed horizontal row of the\n"
05679                                   "image.  The bottom rowgraph is from\n"
05680                                   "the image row under the crosshairs.\n"
05681                                   "Upper rowgraphs are from higher image\n"
05682                                   "rows.  Note that image transformations\n"
05683                                   "functions and image rotations/flips\n"
05684                                   "will affect the rowgraphs as well as\n"
05685                                   "the image display.\n\n"
05686                                   "N.B.: The color 'UK Flag' marker indicates\n"
05687                                   "      the crosshair focus point. It can be\n"
05688                                   "      turned off via the 'No Overlay' button."
05689                                  ) ;
05690             MCW_reghint_children( seq->rowgraph_av->wrowcol ,
05691                                   "Number of image rows to graph" ) ;
05692             nav++ ;
05693          }
05694 
05695          /* 21 Jan 1999: surfgraph */
05696 
05697          if( nav > 0 && seq->status->send_CB != NULL ){
05698             (void) XtVaCreateManagedWidget(
05699                      "menu" , xmSeparatorWidgetClass , rcboxes ,
05700                         XmNseparatorType , XmSINGLE_LINE ,
05701                         XmNinitialResourcesPersistent , False ,
05702                      NULL ) ;
05703 
05704             seq->surfgraph_av =
05705                new_MCW_optmenu( rcboxes , "SurfGraph" ,
05706                                 0 , SURFGRAPH_MAX , seq->surfgraph_num , 0 ,
05707                                 ISQ_surfgraph_CB , (XtPointer) seq ,
05708                                 ISQ_surfgraph_label , NULL ) ;
05709 
05710             MCW_reghelp_children( seq->surfgraph_av->wrowcol ,
05711                                   "The SurfGraph is a wiremesh plot of the\n"
05712                                   "underlay (grayscale) image intensity vs.\n"
05713                                   "x and y.  Use the arrows in the SurfGraph\n"
05714                                   "window to rotate the viewpoint; use the\n"
05715                                   "middle button between the arrows to reset\n"
05716                                   "the viewpoint to the default orientation.\n"
05717                                   "\n"
05718                                   "N.B.: The plotting routine may produce some\n"
05719                                   "        erroneous vertical lines on occasion.\n"
05720                                   "      The color 'UK Flag' marker indicates\n"
05721                                   "        crosshair focus point.  It is drawn\n"
05722                                   "        on top of the surface at the end, and\n"
05723                                   "        so is always visible, even if it should\n"
05724                                   "        be hidden behind the surface; that is,\n"
05725                                   "        it shines through, no matter what.\n"
05726                                   "      The color marker can be turned off with\n"
05727                                   "        the 'No Overlay' button."
05728                                  ) ;
05729             MCW_reghint_children( seq->surfgraph_av->wrowcol ,
05730                                   "Plot wiremesh surface?" ) ;
05731             nav++ ;
05732          }
05733 
05734          /* final separator */
05735 
05736          if( nav ) (void) XtVaCreateManagedWidget(
05737                             "menu" , xmSeparatorWidgetClass , rcboxes ,
05738                                XmNseparatorType , XmSINGLE_LINE ,
05739                                XmNinitialResourcesPersistent , False ,
05740                             NULL ) ;
05741       }
05742 
05743       /*** back to the button box stuff ***/
05744 
05745       seq->bbox[ib] = new_MCW_bbox( rcboxes ,
05746                                      ISQ_dispbb[ib].nbut ,
05747                                      ISQ_dispbb[ib].lbut ,
05748                                      ISQ_dispbb[ib].type ,
05749                                      ISQ_dispbb[ib].frame ,
05750                                      ISQ_disp_act_CB , (XtPointer) seq ) ;
05751 
05752       seq->bbox[ib]->parent = (XtPointer) seq ;
05753 
05754       seq->num_bbox ++ ;
05755 
05756       for( jh=0 ; jh < seq->bbox[ib]->nbut ; jh++ ){
05757          MCW_register_help( seq->bbox[ib]->wbut[jh] , bbh[jh] ) ;
05758          MCW_register_hint( seq->bbox[ib]->wbut[jh] , cch[jh] ) ;
05759       }
05760 
05761    }
05762 
05763 #define NO_GROUP_SCALE
05764 #ifdef  NO_GROUP_SCALE
05765    XtUnmanageChild( seq->bbox[NTOG_SCL]->wtop ) ;  /* turn this box off! */
05766 #endif
05767 
05768    if( seq->last_image_type != MRI_complex )
05769       XtUnmanageChild( seq->bbox[NTOG_CX]->wtop ) ;
05770 
05771    XtManageChild( rcboxes ) ;
05772 
05773    (void) MCW_action_area( rctop , ISQ_disp_act , NACT_DISP ) ;
05774 
05775    XtManageChild( rctop ) ;
05776 
05777    if( swtop != NULL ){       /* 31 Jan 2002 */
05778      int wx,hy , cmax ;
05779      MCW_widget_geom( rctop  , &wx,&hy,NULL,NULL ) ;
05780 
05781      cmax = HeightOfScreen(XtScreen(rctop)) - 128 ;
05782      if( hy > cmax ) hy = cmax ;
05783 
05784      XtVaSetValues( seq->dialog , XmNwidth,wx+29,XmNheight,hy+19 , NULL ) ;
05785    }
05786 
05787    ISQ_place_dialog( seq ) ;  /* 05 Jan 1999 */
05788 
05789    XtPopup( seq->dialog , XtGrabNone ) ;
05790 
05791    ISQ_disp_options( seq , False ) ;  /* set toggles from option list */
05792    seq->save_opt = seq->opt ;         /* for use with Reset button */
05793 
05794    NORMAL_cursorize( seq->dialog ) ;
05795 
05796    ISQ_but_done_reset( seq ) ;
05797    EXRETURN ;
05798 }

03919 {
03920    MCW_imseq * seq = (MCW_imseq *) client_data ;
03921 
03922 ENTRY("ISQ_but_done_CB") ;
03923 
03924    if( ! ISQ_VALID(seq) ) EXRETURN ;
03925 
03926 #ifdef REQUIRE_TWO_DONES
03927    /*-- first call from "Done" button --> change label, return */
03928 
03929    if( w == seq->wbut_bot[NBUT_DONE] && seq->done_first ){
03930       MCW_set_widget_label( w , ISQ_but_done_label2 ) ;
03931       seq->done_first = False ;
03932       EXRETURN ;
03933    }
03934 #endif
03935 
03936    /*-- second call: kill --*/
03937 
03938    if( seq->glstat->worker != 0 ){  /* remove work process, if started */
03939       XtRemoveWorkProc( seq->glstat->worker ) ;
03940       seq->glstat->worker = 0 ;
03941    }
03942 
03943    ISQ_timer_stop(seq) ;
03944 
03945    if( seq->dialog != NULL ) XtDestroyWidget( seq->dialog ) ;  /* 13 Aug 2002 */
03946 
03947    ISQ_free_alldata( seq ) ;
03948    XtDestroyWidget( seq->wtop ) ;
03949    seq->valid = 0 ;     /* WE do not deallocate the data structure! */
03950 
03951    STATUS("IMSEQ: data destroyed!") ;
03952 
03953    if( seq->status->send_CB != NULL ){
03954       ISQ_cbs cbs ;
03955 
03956       STATUS("IMSEQ: sending destroy message") ;
03957 
03958       cbs.reason = isqCR_destroy ;
03959 #if 0
03960       seq->status->send_CB( seq , seq->getaux , &cbs ) ;
03961 #else
03962       SEND(seq,cbs) ;
03963 #endif
03964    }
03965 
03966    EXRETURN ;
03967 }

03881 {
03882    MCW_imseq * seq = (MCW_imseq *) client_data ;
03883 
03884 ENTRY("ISQ_but_save_CB") ;
03885 
03886    if( ! ISQ_REALZ(seq) || w == NULL || ! XtIsWidget(w) ) EXRETURN ;
03887 
03888    seq->saver_prefix = NULL ;
03889    seq->saver_from = seq->saver_to = -1 ;
03890 
03891    MCW_choose_string( w , "Filename prefix:" , NULL ,
03892                       ISQ_saver_CB , (XtPointer) seq ) ;
03893 
03894    ISQ_but_done_reset( seq ) ;
03895    EXRETURN ;
03896 }

10048 {
10049    MCW_imseq * seq = (MCW_imseq *) client_data ;
10050    int pp , agif_ind=0 , mpeg_ind=0 , nstr ;
10051 
10052    if( !ISQ_REALZ(seq)               ||
10053        cbs->reason != mcwCR_integer  ||
10054        seq->dialog_starter==NBUT_DISP  ){  /* bad things */
10055 
10056       XBell(XtDisplay(w),100); POPDOWN_strlist_chooser ; return ;
10057    }
10058 
10059    nstr = ppmto_num+1 ;
10060    if( ppmto_agif_filter != NULL ) agif_ind = nstr++ ;
10061    if( ppmto_mpeg_filter != NULL ) mpeg_ind = nstr++ ;
10062 
10063    seq->opt.save_nsize = seq->opt.save_pnm
10064                        = seq->opt.save_agif = seq->opt.save_mpeg = 0 ;
10065 
10066    pp = cbs->ival ;
10067         if( pp == 0         ) seq->opt.save_filter=-1  ; /* Save:bkg */
10068    else if( pp <= ppmto_num ) seq->opt.save_filter=pp-1; /* Save.typ */
10069    else if( pp == agif_ind  ) seq->opt.save_agif  = 1  ; /* Sav:aGif */
10070    else if( pp == mpeg_ind  ) seq->opt.save_mpeg  = 1  ; /* Sav:mpeg */
10071 
10072    if( ppmto_agif_filter == NULL ) seq->opt.save_agif = 0 ;  /* 07 Apr 2005 */
10073    if( ppmto_mpeg_filter == NULL ) seq->opt.save_mpeg = 0 ;
10074 
10075    SET_SAVE_LABEL(seq) ; return ;
10076 }

10085 {
10086    MCW_imseq * seq = (MCW_imseq *) client_data ;
10087 
10088    if( !ISQ_REALZ(seq) ) return ;
10089 
10090    ISQ_timer_stop(seq) ;
10091 
10092    switch( ev->type ){
10093       case ButtonPress:{
10094          XButtonEvent * event = (XButtonEvent *) ev ;
10095          if( event->button == Button3 ){
10096             char **strlist ; int pp , nstr , agif_ind=0 , mpeg_ind=0 ;
10097             if( seq->dialog_starter==NBUT_DISP ){XBell(XtDisplay(w),100); return; }
10098             strlist = (char **) malloc(sizeof(char *)*(ppmto_num+3)) ;
10099             strlist[0] = strdup("Save:bkg") ;             /* special case */
10100             for( pp=0 ; pp < ppmto_num ; pp++ ){          /* filters */
10101                strlist[pp+1] = AFMALL( char, 16) ;
10102                sprintf(strlist[pp+1],"Save.%.3s",ppmto_suffix[pp]) ;
10103             }
10104             nstr = ppmto_num+1 ;
10105             if( ppmto_agif_filter != NULL ){
10106                agif_ind = nstr ;
10107                strlist[nstr++] = strdup("Sav:aGif") ;     /* special case */
10108             }
10109             if( ppmto_mpeg_filter != NULL ){
10110                mpeg_ind = nstr ;
10111                strlist[nstr++] = strdup("Sav:mpeg") ;     /* special case */
10112             }
10113                  if(seq->opt.save_agif && agif_ind > 0 ) pp=agif_ind ;
10114             else if(seq->opt.save_mpeg && mpeg_ind > 0 ) pp=mpeg_ind ;
10115             else if(seq->opt.save_filter < 0)            pp=0        ;
10116             else                                     pp=seq->opt.save_filter+1 ;
10117             MCW_choose_strlist( w , "Image Save format" ,
10118                                 nstr , pp , strlist ,
10119                                 ISQ_butsave_choice_CB , (XtPointer) seq ) ;
10120             for( pp=0 ; pp < nstr ; pp++ ) free(strlist[pp]) ;
10121             free(strlist) ;
10122          } else if( event->button == Button2 ){
10123             XBell(XtDisplay(w),100) ;
10124             MCW_popup_message( w, " \n Ouch! \n ", MCW_USER_KILL );
10125             /** AFNI_speak( "Ouch!" , 0 ) ; **/
10126          }
10127       }
10128       break ;
10129    }
10130    return ;
10131 }

05213 {
05214    MCW_imseq * seq = (MCW_imseq *) client_data ;
05215    ISQ_cbs cbs ;
05216    static int nsav ;
05217    static int * bxsav=NULL , *bysav=NULL , *xyout=NULL ;
05218 
05219 ENTRY("ISQ_button2_EV") ;
05220 
05221    /* check for legality */
05222 
05223    if( !ISQ_REALZ(seq) || !seq->button2_enabled || w != seq->wimage ) EXRETURN ;
05224 
05225    ISQ_timer_stop(seq) ;
05226 
05227    switch( ev->type ){
05228 
05229       /*----- take button press -----*/
05230 
05231       case ButtonPress:{
05232          XButtonEvent * event = (XButtonEvent *) ev ;
05233          int bx,by , but , xim,yim,zim ;
05234 
05235          but = event->button ; if( but != Button2 ) EXRETURN ;
05236 
05237          seq->button2_active = 1 ;  /* allow other button2 stuff to happen */
05238 
05239          /* 1st time in: allocate space to save points */
05240 
05241          if( bxsav == NULL ){
05242             bxsav = (int *) malloc( sizeof(int) * (NPTS_MAX+1) ) ;
05243             bysav = (int *) malloc( sizeof(int) * (NPTS_MAX+1) ) ;
05244          }
05245 
05246          /* save this point */
05247 
05248          bx = event->x ; by = event->y ;
05249          bxsav[0] = bx ; bysav[0] = by ; nsav = 1 ;
05250 
05251          /* find where this point is in original images --
05252             if it is illegal, quit this mockery of a travesty of a sham */
05253 
05254          seq->wimage_width = -1 ;
05255          ISQ_mapxy( seq , bx,by , &xim,&yim,&zim ) ;
05256          if( xim < 0 || yim < 0 || zim < 0 || zim >= seq->status->num_total ){
05257             seq->button2_active = 0 ;         /* disallow button2 stuff */
05258             XBell( seq->dc->display , 100 ) ; /* express our displeasure */
05259             EXRETURN ;
05260          }
05261 
05262          /* draw this point */
05263 
05264          if( seq->button2_drawmode != BUTTON2_NODRAW ){
05265             DC_fg_colorpix( seq->dc , seq->button2_pixel ) ;
05266             XDrawPoint( seq->dc->display , XtWindow(seq->wimage) ,
05267                         seq->dc->myGC , bx,by ) ;
05268          }
05269       }
05270       break ;
05271 
05272       /*----- take button release -----*/
05273 
05274       case ButtonRelease:{
05275          XButtonEvent * event = (XButtonEvent *) ev ;
05276          int bx,by ;
05277          int ii,nout , nim , xim,yim,zim ;
05278 
05279          /* check for legality  */
05280 
05281          if( !seq->button2_active || event->button != Button2 ) EXRETURN ;
05282 
05283          bx = event->x ; by = event->y ;  /* where did it happen? */
05284 
05285          /* if a new point, save it and draw it */
05286 
05287          if( bx != bxsav[nsav-1] || by != bysav[nsav-1] ){
05288 
05289             if( seq->button2_drawmode == BUTTON2_POINTS ){
05290                XDrawPoint( seq->dc->display , XtWindow(seq->wimage) ,
05291                            seq->dc->myGC , bx,by ) ;
05292             } else if( seq->button2_drawmode != BUTTON2_NODRAW ){
05293                if( seq->button2_width > 0 )                     /* 08 Oct 2002 */
05294                  DC_linewidth( seq->dc , seq->button2_width ) ;
05295                XDrawLine( seq->dc->display , XtWindow(seq->wimage) ,
05296                           seq->dc->myGC , bxsav[nsav-1],bysav[nsav-1],bx,by ) ;
05297                if( seq->button2_width > 0 ) DC_linewidth( seq->dc , 0 ) ;
05298             }
05299 
05300             bxsav[nsav] = bx ; bysav[nsav] = by ;
05301             if( nsav < NPTS_MAX ) nsav++ ;
05302          }
05303 
05304          /* this is the last point in this sequence --
05305             if we are drawing closed polygon, then close it now */
05306 
05307          if( seq->button2_drawmode == BUTTON2_CLOSEDPOLY && nsav > 2 ){
05308             if( seq->button2_width > 0 )                     /* 08 Oct 2002 */
05309               DC_linewidth( seq->dc , seq->button2_width ) ;
05310             XDrawLine( seq->dc->display , XtWindow(seq->wimage) ,
05311                        seq->dc->myGC , bxsav[nsav-1],bysav[nsav-1] ,
05312                                        bxsav[0]     ,bysav[0]       ) ;
05313             if( seq->button2_width > 0 ) DC_linewidth( seq->dc , 0 ) ;
05314 
05315             /* and add the 1st point to the list again */
05316 
05317             bxsav[nsav] = bxsav[0] ; bysav[nsav] = bysav[0] ;
05318             if( nsav < NPTS_MAX ) nsav++ ;
05319          }
05320 
05321          /* 1st time here: make space for output list */
05322 
05323          if( xyout == NULL )
05324             xyout = (int *) malloc( sizeof(int) * 2*NPTS_MAX ) ;
05325 
05326          /* now assemble output list of (x,y) pairs,
05327             in the original image grid --
05328             but only save points that are in the same image as the 1st point */
05329 
05330          seq->wimage_width = -1 ;
05331          ISQ_mapxy( seq , bxsav[0] , bysav[0] , &xim,&yim,&zim ) ;
05332          nim = zim ; xyout[0] = xim ; xyout[1] = yim ; nout = 1 ;
05333          for( ii=1 ; ii < nsav ; ii++ ){
05334             ISQ_mapxy( seq , bxsav[ii] , bysav[ii] , &xim,&yim,&zim ) ;
05335             if( zim == nim && xim >= 0 && yim >= 0 ){
05336                xyout[2*nout] = xim ; xyout[2*nout+1] = yim ;
05337                nout++ ;
05338             }
05339          }
05340 
05341          /* send to the almighty AFNI */
05342 
05343          cbs.reason   = isqCR_button2_points ;
05344          cbs.event    = ev ;
05345          cbs.key      = ii ;                 /* number of points */
05346          cbs.nim      = nim ;                /* z coord */
05347          cbs.userdata = (XtPointer) xyout ;  /* x & y coords */
05348 #if 0
05349          seq->status->send_CB( seq , seq->getaux , &cbs ) ;
05350 #else
05351          SEND(seq,cbs) ;
05352 #endif
05353 
05354          seq->button2_active = 0 ;  /* disallow button2 stuff */
05355       }
05356       break ;
05357 
05358       /*----- take motion events:
05359               this is minimal so as to keep up with mouse movements -----*/
05360 
05361       case MotionNotify:{
05362          XMotionEvent * event = (XMotionEvent *) ev ;
05363          int bx,by ;
05364 
05365          /* check for legality */
05366 
05367          if( !seq->button2_active || (event->state & Button2Mask) == 0 ) EXRETURN ;
05368 
05369          /* if point is redundant with last one, skip it */
05370 
05371          bx = event->x ; by = event->y ;
05372          if( bx == bxsav[nsav-1] && by == bysav[nsav-1] ) EXRETURN ;
05373 
05374          /* draw point or line to point */
05375 
05376          if( seq->button2_drawmode == BUTTON2_POINTS ){
05377             XDrawPoint( seq->dc->display , XtWindow(seq->wimage) ,
05378                         seq->dc->myGC , bx,by ) ;
05379          } else if( seq->button2_drawmode != BUTTON2_NODRAW ){
05380             if( seq->button2_width > 0 )                     /* 08 Oct 2002 */
05381               DC_linewidth( seq->dc , seq->button2_width ) ;
05382             XDrawLine( seq->dc->display , XtWindow(seq->wimage) ,
05383                        seq->dc->myGC , bxsav[nsav-1],bysav[nsav-1],bx,by ) ;
05384             if( seq->button2_width > 0 ) DC_linewidth( seq->dc , 0 ) ;
05385          }
05386 
05387          /* save it */
05388 
05389          bxsav[nsav] = bx ; bysav[nsav] = by ;
05390          if( nsav < NPTS_MAX ) nsav++ ;
05391       }
05392       break ;
05393 
05394    }
05395    EXRETURN ;
05396 }

01922 {
01923    MCW_imseq_status * outstat ;
01924 
01925 ENTRY("ISQ_copy_status") ;
01926 
01927    outstat = (MCW_imseq_status *) XtMalloc( sizeof(MCW_imseq_status) ) ;
01928 
01929    *outstat = *instat ;   /* shallow copy for now (no pointers) */
01930    RETURN(outstat) ;
01931 }

02109 {
02110    MCW_imseq * seq = (MCW_imseq *) client_data ;
02111 
02112 ENTRY("ISQ_crop_pb_CB") ;
02113 
02114    if( !ISQ_REALZ(seq)        ||
02115        w != seq->crop_drag_pb ||
02116        ! seq->crop_allowed      ){ XBell(XtDisplay(w),100); EXRETURN; }
02117 
02118    MCW_invert_widget( seq->crop_drag_pb ) ;
02119    seq->crop_drag = !seq->crop_drag ;
02120 
02121    if( !seq->crop_drag && seq->cropit ){        /* turn crop off */
02122      seq->cropit = 0 ; seq->crop_nxorg = -1 ;   /* if double-pressed */
02123      ISQ_redisplay( seq , -1 , isqDR_display ) ;
02124    }
02125 
02126    if( seq->zoom_button1 ){                     /* turn pan off if on */
02127      POPUP_cursorize( seq->wimage ) ;
02128      MCW_invert_widget( seq->zoom_drag_pb ) ;
02129      seq->zoom_button1 = 0 ;
02130    }
02131 
02132    EXRETURN ;
02133 }

10420 {
10421 #define MINCROP 9
10422 
10423    int x1=event->x,y1=event->y , x2,y2 ;
10424    int imx1,imy1,nim1 , imx2,imy2,nim2 , tt ;
10425    int zlev = seq->zoom_fac ;
10426 
10427 ENTRY("ISQ_cropper") ;
10428 
10429    if( !seq->crop_allowed ){
10430      XBell(seq->dc->display,100); EXRETURN;
10431    }
10432 
10433    /*** make the user drag a rectangle while button is pressed:
10434         (x1,y1) = window coords of rectangle start
10435         (x2,y2) = window coords of rectangle finish         ***/
10436 
10437 #if 1
10438    RWC_drag_rectangle( seq->wimage , x1,y1,&x2,&y2 ) ;
10439 #else
10440    { int rad ;
10441      RWC_drag_circle( seq->wimage , x1,y1 , &rad ) ;  /** just a test **/
10442      fprintf(stderr,"rad=%d\n",rad) ; EXRETURN ;
10443    }
10444 #endif
10445 
10446    /*** find corners of rectangle in original image pixels ***/
10447 
10448    ISQ_mapxy( seq , x1,y1 , &imx1,&imy1,&nim1 ) ;
10449    ISQ_mapxy( seq , x2,y2 , &imx2,&imy2,&nim2 ) ;
10450 
10451    /*** ensure coords of rectangle run upwards (upperleft to lowerright) ***/
10452 
10453    if( imx1 > imx2 ){ tt = imx1; imx1 = imx2; imx2 = tt; }
10454    if( imy1 > imy2 ){ tt = imy1; imy1 = imy2; imy2 = tt; }
10455 
10456    /*** if dragging occured across sub-images in a montage,
10457         or if rectangle edge is in a Montage's inter-image border */
10458 
10459    if( nim1 != nim2 || imx1 < 0 || imy1 < 0 ){
10460      static int npop=0 ;
10461      char str[64] ;
10462      if( npop < 5 ){
10463 #define NINSULT 17
10464        static char *ins[NINSULT]={
10465                       "Stupid","Moronic","Cretinous","Idiotic","Bozonic",
10466                       "Criminal","Repulsive","Dumb",
10467                       "Pinheaded","Fatuous","Asinine","Imbecilic",
10468                       "Oafish","Doltish","Duncical","Witless","Brainless" };
10469        int ii = (lrand48()>>5) % NINSULT ;
10470        sprintf(str," \n  %s \n  crop\n  rectangle! \n ",ins[ii]) ;
10471        MCW_popup_message( seq->wimage,str, MCW_USER_KILL|MCW_TIMER_KILL ) ;
10472        npop++ ;
10473      }
10474      XBell(seq->dc->display,100); goto CropDone;
10475    }
10476 
10477    /*** if crop window is too small, then deal with that ***/
10478 
10479    if( imx2-imx1 < MINCROP || imy2-imy1 < MINCROP ){ /* too small */
10480      if( imx2-imx1 < 2 || imy2-imy1 < 2 ){
10481        seq->cropit = 0 ; seq->crop_nxorg = -1 ;  /* turn crop off */
10482      } else {
10483        XBell(seq->dc->display,100);                 /* do nothing */
10484      }
10485 
10486    /*** otherwise (not too small), set the crop region ***/
10487 
10488    } else {
10489 
10490      /* 14 Jun 2002: if we are also zoomed, things are more complex */
10491 
10492      if( zlev > 1 ){
10493 
10494        /* xmid = middle of crop region */
10495        /* xh   = half-width of crop region, as drawn */
10496        /* xhw  = half-width enlarged by zoom factor */
10497 
10498        int xmid=(imx2+imx1)/2, xh=(imx2-imx1)/2, xhw=zlev*xh ;
10499        int ymid=(imy2+imy1)/2, yh=(imy2-imy1)/2, yhw=zlev*yh ;
10500        int nx,ny ;
10501        float mh = (zlev-1.001)/zlev ;  /* max offset allowed */
10502 
10503        /* set size of original image from which cropping will be done */
10504 
10505        nx = (seq->crop_nxorg > 0) ? seq->crop_nxorg : seq->horig ;
10506        ny = (seq->crop_nxorg > 0) ? seq->crop_nyorg : seq->vorig ;
10507 #if 0
10508 fprintf(stderr,"Crop: imx1=%d imx2=%d xmid=%d xh=%d xhw=%d nx=%d\n",imx1,imx2,xmid,xh,xhw,nx);
10509 fprintf(stderr,"      imy1=%d imy2=%d ymid=%d yh=%d yhw=%d ny=%d\n",imy1,imy2,ymid,yh,yhw,ny);
10510 #endif
10511 
10512        /* cropping should run from imx1-xhw to imx2+xhw
10513           (since we want the image window to show what the user
10514            drew, so we have to crop a larger rectangle and then
10515            zoom in on THAT),
10516           but we can't go outside the original image boundaries,
10517           so we recompute imx1..imx2 here                       */
10518 
10519        imx1 = xmid-xhw ; imx2 = xmid+xhw ;
10520             if( imx1 <  0    ){ imx1 = 0   ; imx2 = imx1+2*xhw; }
10521        else if( imx2 >= nx-1 ){ imx2 = nx-1; imx1 = imx2-2*xhw; }
10522        imy1 = ymid-yhw ; imy2 = ymid+yhw ;
10523             if( imy1 <  0    ){ imy1 = 0   ; imy2 = imy1+2*yhw; }
10524        else if( imy2 >= ny-1 ){ imy2 = ny-1; imy1 = imy2-2*yhw; }
10525 
10526        /* set the offset for the zoom window so that we'll show
10527           the crop region just computed in the image display    */
10528 
10529        if( seq->opt.mirror )
10530          seq->zoom_hor_off = ((float)(imx2-xmid-xh))
10531                             /((float)(imx2-imx1)) ;
10532        else
10533          seq->zoom_hor_off = ((float)(xmid-xh-imx1))
10534                             /((float)(imx2-imx1)) ;
10535 
10536        seq->zoom_ver_off = ((float)(ymid-yh-imy1))
10537                           /((float)(imy2-imy1)) ;
10538 #if 0
10539 fprintf(stderr,"      imx1=%d imx2=%d hor_off=%f\n",imx1,imx2,seq->zoom_hor_off);
10540 fprintf(stderr,"      imy1=%d imy2=%d ver_off=%f\n",imy1,imy2,seq->zoom_ver_off);
10541 #endif
10542 
10543        /* safeguard: don't let the zoom window offset be out of range! */
10544 
10545             if( seq->zoom_hor_off > mh  ) seq->zoom_hor_off = mh  ;
10546        else if( seq->zoom_hor_off < 0.0 ) seq->zoom_hor_off = 0.0 ;
10547             if( seq->zoom_ver_off > mh  ) seq->zoom_ver_off = mh  ;
10548        else if( seq->zoom_ver_off < 0.0 ) seq->zoom_ver_off = 0.0 ;
10549 
10550      } /* end of mangling crop+zoom interaction */
10551 
10552      /* now set crop parameters */
10553 
10554      seq->crop_xa = imx1 ; seq->crop_xb = imx2 ;
10555      seq->crop_ya = imy1 ; seq->crop_yb = imy2 ;
10556      seq->cropit = 1 ; seq->crop_nxorg = -1 ;
10557    }
10558 
10559    /*** force image redisplay ***/
10560 
10561 CropDone:
10562    if( seq->crop_drag ){                       /* turn off crop */
10563      MCW_invert_widget( seq->crop_drag_pb ) ;  /* button, if on */
10564      seq->crop_drag = 0 ;
10565    }
10566 
10567    ISQ_redisplay( seq , -1 , isqDR_display ) ;
10568    EXRETURN ;
10569 }

05848 {
05849    MCW_imseq * seq           = (MCW_imseq *) client_data ;
05850    XmAnyCallbackStruct * cbs = (XmAnyCallbackStruct *) call_data ;
05851 
05852    int ib , close_window ;
05853    char * wname ;
05854    Boolean new_opt = False ;
05855 
05856 #ifdef FLASH_TOGGLE
05857    Boolean flasher ;
05858 #endif
05859 
05860 ENTRY("ISQ_disp_act_CB") ;
05861 
05862    if( !ISQ_REALZ(seq) || seq->dialog==NULL || seq->dialog_starter!=NBUT_DISP ) EXRETURN ;
05863 
05864    wname = XtName(w) ;
05865 
05866    for( ib=0 ; ib < NACT_DISP ; ib++ )           /* button index, if any */
05867       if( strcmp(wname,ISQ_disp_act[ib].label) == 0 ) break ;
05868 
05869    close_window = (ib == DISP_OK)  /* button to exit */
05870                  ||
05871                   ( cbs->reason != XmCR_ACTIVATE       &&   /* exit if */
05872                     cbs->reason != XmCR_DISARM           ); /* not button */
05873 
05874 #ifdef FLASH_TOGGLE
05875    flasher = (cbs->reason == XmCR_DISARM) && (!close_window) ;
05876    if( flasher ) MCW_invert_widget( w ) ;
05877 #endif
05878 
05879    if( ib == DISP_UNDO ){               /* restore options from entry */
05880       seq->opt = seq->save_opt ;        /* and then set toggles */
05881       ISQ_disp_options( seq , False ) ;
05882       new_opt = True ;
05883       AV_SENSITIZE(seq->ov_opacity_av,!seq->opt.no_overlay) ; /* 09 Mar 2001 */
05884 
05885    } else {                                     /* any other activation: */
05886       new_opt = ISQ_disp_options( seq , True ); /* --> set options */
05887    }
05888 
05889    if( close_window ){                          /* close the window */
05890       XtDestroyWidget( seq->dialog ) ;
05891       seq->dialog = NULL ;
05892       for( ib=0 ; ib < NBUTTON_BOT-1 ; ib++ )       /* turn buttons back on */
05893          if( ISQ_but_bot_dial[ib] == True )         /* that also want to   */
05894             SENSITIZE( seq->wbut_bot[ib] , True ) ; /* use seq->dialog    */
05895 
05896       for( ib=0 ; ib < seq->num_bbox ; ib++ ) myXtFree( seq->bbox[ib] ) ;
05897       seq->num_bbox = 0 ;
05898       seq->dialog_starter = -1 ;
05899 
05900       FREE_AV( seq->transform0D_av ) ;
05901       FREE_AV( seq->transform2D_av ) ;
05902       FREE_AV( seq->rowgraph_av )    ;
05903       FREE_AV( seq->surfgraph_av )   ;  /* 21 Jan 1999 */
05904    }
05905 
05906    if( new_opt ){
05907       ISQ_redisplay( seq , -1 , isqDR_reimage ) ;  /* redo current image */
05908 
05909       /* 01 Dec 1999: perhaps redraw winfo label */
05910 
05911       if( ISQ_USE_SIDES(seq) ){
05912          seq->im_label[0] = '\0' ;  /* will force redraw */
05913          ISQ_draw_winfo( seq ) ;
05914       }
05915    }
05916 
05917 #ifdef FLASH_TOGGLE
05918    if( flasher ) MCW_invert_widget( w ) ;  /* flash togglebutton */
05919 #endif
05920 
05921    ISQ_but_done_reset( seq ) ;
05922    EXRETURN ;
05923 }

05934 {
05935    int bval[NBOX_DISP] ;
05936    int ib ;
05937 
05938 ENTRY("ISQ_disp_options") ;
05939 
05940    if( !ISQ_VALID(seq) || seq->dialog==NULL || seq->dialog_starter!=NBUT_DISP )
05941       RETURN(False) ;
05942 
05943    if( set ){
05944       ISQ_options inopt = seq->opt ;
05945       Boolean changed ;
05946 
05947       for( ib=0 ; ib < NBOX_DISP ; ib++ )
05948          bval[ib] = MCW_val_bbox( seq->bbox[ib] ) ;
05949 
05950       seq->opt.mirror      = ( bval[NTOG_MIR] & 1 ) != 0 ;
05951 
05952       seq->opt.rot         = bval[NTOG_ROT] ;
05953 
05954       seq->opt.no_overlay  = ( bval[NTOG_COL] & 1 ) != 0 ;
05955 
05956       AV_SENSITIZE(seq->ov_opacity_av,!seq->opt.no_overlay) ; /* 09 Mar 2001 */
05957 
05958       seq->opt.scale_group = bval[NTOG_SCL] ;
05959 
05960       seq->opt.scale_range = bval[NTOG_RNG] ;
05961 
05962       seq->opt.free_aspect = ( bval[NTOG_ASP] & ISQ_ASPECT    ) != 0 ;
05963       seq->opt.save_nsize  = ( bval[NTOG_SAV] & ISQ_SAV_NSIZE ) != 0 ;
05964       seq->opt.save_pnm    = ( bval[NTOG_SAV] & ISQ_SAV_PNM   ) != 0 ;
05965 
05966       seq->opt.save_one    = MCW_val_bbox(seq->save_one_bbox)   != 0 ; /* 26 Jul 2001 */
05967 
05968       seq->opt.save_agif = seq->opt.save_mpeg = 0 ;
05969       if( seq->save_agif_bbox != NULL ){
05970          int bv = MCW_val_bbox(seq->save_agif_bbox) ;
05971                                                         /* 07 Apr 2005: oops */
05972          switch( bv ){        /* need to handle case when agif isn't allowed */
05973            case 1:
05974                   if( ppmto_agif_filter != NULL ) seq->opt.save_agif = 1 ;
05975              else if( ppmto_mpeg_filter != NULL ) seq->opt.save_mpeg = 1 ;
05976            break ;
05977 
05978            case 2:
05979                   if( ppmto_mpeg_filter != NULL ) seq->opt.save_mpeg = 1 ;
05980            break ;
05981          }
05982       }
05983 
05984       seq->opt.save_filter = -1 ;
05985       if( bval[NTOG_SAV] > ISQ_SAV_PNM && ppmto_num > 0 ){  /* 27 Jun 2001 */
05986          int ii ;
05987          for( ii=0 ; ii < ppmto_num ; ii++ ){
05988             if( bval[NTOG_SAV] == ppmto_bval[ii] ){
05989                seq->opt.save_filter = ii ; break ;
05990             }
05991          }
05992       }
05993 
05994       SET_SAVE_LABEL(seq) ;
05995 
05996       seq->opt.improc_code = bval[NTOG_IMP] ;
05997 
05998       seq->opt.cx_code = bval[NTOG_CX] ;
05999 
06000       /* sanity checks */
06001 
06002       if( seq->opt.rot != ISQ_ROT_0   &&
06003           seq->opt.rot != ISQ_ROT_90  &&
06004           seq->opt.rot != ISQ_ROT_180 &&
06005           seq->opt.rot != ISQ_ROT_270   ) seq->opt.rot = inopt.rot ;
06006 
06007       if( seq->opt.scale_group != ISQ_SCL_AUTO &&
06008           seq->opt.scale_group != ISQ_SCL_GRP )
06009                                seq->opt.scale_group = inopt.scale_group ;
06010 
06011       if( seq->opt.scale_range != ISQ_RNG_MINTOMAX &&
06012           seq->opt.scale_range != ISQ_RNG_02TO98 )
06013                                seq->opt.scale_range = inopt.scale_range ;
06014 
06015       changed = ! ISQ_OPT_EQUAL( seq->opt , inopt ) ;
06016 
06017       RETURN(changed) ;
06018 
06019    } else {
06020 
06021       bval[NTOG_MIR] = (seq->opt.mirror) ? 1 : 0 ;
06022       bval[NTOG_ROT] = seq->opt.rot ;
06023 
06024       bval[NTOG_COL] = (seq->opt.no_overlay << 0 ) ;
06025 
06026       bval[NTOG_SCL] = seq->opt.scale_group ;
06027       bval[NTOG_RNG] = seq->opt.scale_range ;
06028 
06029       bval[NTOG_ASP] = (seq->opt.free_aspect) ? ISQ_ASPECT    : 0 ;
06030 
06031       bval[NTOG_SAV] = ( (seq->opt.save_nsize)? ISQ_SAV_NSIZE : 0 )
06032                       +( (seq->opt.save_pnm)  ? ISQ_SAV_PNM   : 0 ) ;
06033 
06034       if( seq->opt.save_filter >= 0 && ppmto_num > 0 )       /* 27 Jun 2001 */
06035          bval[NTOG_SAV] = ppmto_bval[seq->opt.save_filter] ;
06036 
06037       bval[NTOG_IMP] = seq->opt.improc_code ;
06038 
06039       bval[NTOG_CX]  = seq->opt.cx_code ;
06040 
06041       for( ib=0 ; ib < NBOX_DISP ; ib++ )
06042          MCW_set_bbox( seq->bbox[ib] , bval[ib] ) ;
06043 
06044       MCW_set_bbox( seq->save_one_bbox ,
06045                     (seq->opt.save_one) ? 1 : 0 ) ; /* 26 Jul 2001 */
06046 
06047       if( seq->save_agif_bbox != NULL ){      /* 07 Apr 2005: oops */
06048          int bv=0 ; /* need to handle case when agif isn't allowed */
06049          if( ppmto_agif_filter != NULL )
06050            bv = (seq->opt.save_agif) + (seq->opt.save_mpeg)*2 ;
06051          else if( ppmto_mpeg_filter != NULL )
06052            bv = (seq->opt.save_mpeg) ;
06053          MCW_set_bbox( seq->save_agif_bbox , bv ) ;
06054       }
06055 
06056       RETURN(False) ;
06057    }
06058 }

04531 {
04532    char buf[128] = "\0" ;
04533    int nn , ibuf ;
04534    ISQ_indiv_statistics * st ;
04535 
04536 ENTRY("ISQ_draw_winfo") ;
04537 
04538    if( ! ISQ_REALZ(seq) ) EXRETURN ;
04539 
04540    if( seq->last_image_type >= 0 ){
04541      sprintf( buf , "%s" , MRI_TYPE_name[seq->last_image_type] ) ;
04542 
04543      if( seq->last_image_type == MRI_complex ){
04544        switch( seq->opt.cx_code ){
04545          case ISQ_CX_MAG:   strcat( buf , "[mag]"  ) ; break ;
04546          case ISQ_CX_PHASE: strcat( buf , "[arg]"  ) ; break ;
04547          case ISQ_CX_REAL:  strcat( buf , "[real]" ) ; break ;
04548          case ISQ_CX_IMAG:  strcat( buf , "[imag]" ) ; break ;
04549        }
04550      }
04551    }
04552    ibuf = strlen(buf) ;
04553 
04554    nn = seq->im_nr ;  if( nn < 0 ) EXRETURN ;
04555    st = &( seq->imstat[nn] ) ;
04556    if( st->one_done ){
04557 #if 0
04558       if( seq->opt.scale_group == ISQ_SCL_AUTO   &&
04559           seq->opt.scale_range == ISQ_RNG_02TO98    )
04560 
04561            sprintf( buf+ibuf , " 2%%=%g 98%%=%g", st->per02 , st->per98 ) ;
04562       else
04563 #endif
04564            sprintf( buf+ibuf , "=%g..%g ent=%.2f" ,
04565                     st->min , st->max , st->entropy ) ;
04566    }
04567 
04568    if( seq->im_label[0] == '\0' || strcmp(buf,seq->im_label) != 0 ){
04569      if( seq->winfo_extra[0] == '\0' ){
04570 
04571        int iw=0 ;                                   /* winfo_sides stuff */
04572        switch( seq->opt.rot ){                      /* from 01 Dec 1999  */
04573          case ISQ_ROT_0  : iw=0 ; break ;
04574          case ISQ_ROT_90 : iw=1 ; break ;
04575          case ISQ_ROT_180: iw=2 ; break ;
04576          case ISQ_ROT_270: iw=3 ; break ;
04577        }
04578        if( seq->opt.mirror ) iw = (iw+2)%4 ;
04579 
04580        if( seq->winfo_sides[iw][0] != '\0' ){
04581          char qbuf[128] ;
04582          strcpy(qbuf,"left=") ;
04583          strcat(qbuf,seq->winfo_sides[iw]) ;
04584          strcat(qbuf," ") ; strcat(qbuf,buf) ;
04585          MCW_set_widget_label( seq->winfo , qbuf ) ;
04586        } else {
04587          MCW_set_widget_label( seq->winfo , buf ) ;   /* default label! */
04588        }
04589 
04590      } else {                                        /* winfo_extra stuff */
04591        char qbuf[128] ;                             /* from 07 Aug 1999  */
04592        strcpy(qbuf,seq->winfo_extra) ;
04593        strcat(qbuf," ") ; strcat(qbuf,buf) ;
04594        MCW_set_widget_label( seq->winfo , qbuf ) ;
04595      }
04596      strcpy(seq->im_label,buf) ;
04597    }
04598 
04599    EXRETURN ;
04600 }

04712 {
04713    MCW_imseq * seq = (MCW_imseq *) client_data ;
04714    static ISQ_cbs cbs ;
04715    static int busy=0 ;   /* 23 Jan 2004: prevent recursion */
04716 
04717 ENTRY("ISQ_drawing_EV") ;
04718 
04719    if( busy ){ STATUS("recursive entry!"); EXRETURN; }  /* bad! */
04720    if( !ISQ_REALZ(seq) ) EXRETURN ;
04721    busy = 1 ;
04722 
04723    if(PRINT_TRACING){
04724      char str[256], *wn ;
04725           if( w == seq->wimage ) wn = "wimage" ;
04726      else if ( w == seq->wbar  ) wn = "wbar"   ;
04727      else                        wn = XtName(w) ;
04728      sprintf(str,"Widget=%s Event type=%d",wn,ev->type);
04729      STATUS(str) ;
04730    }
04731 
04732    switch( ev->type ){
04733 
04734       /*----- button release event -----*/
04735 
04736       case ButtonRelease:{
04737          XButtonEvent * event = (XButtonEvent *) ev ;
04738          int but = event->button ;
04739 
04740          /** 03 Oct 2002: change Shift+Button1 into Button2, then send to that event handler **/
04741 
04742          if( but == Button1 &&
04743              ( seq->cursor_state == CURSOR_PENCIL ||
04744                ((event->state & ShiftMask) && !(event->state & ControlMask)) ) ){
04745            event->button = but = Button2 ;
04746            if( seq->button2_enabled && w == seq->wimage )
04747               ISQ_button2_EV( w , client_data , ev , continue_to_dispatch ) ;
04748            else
04749               { XBell(seq->dc->display,100); busy=0;EXRETURN; }
04750          }
04751 
04752          /* Button1 release: turn off zoom-pan mode, if it was on */
04753 
04754          if( event->button == Button1 && w == seq->wimage ){
04755 
04756            if( seq->zoom_button1 && !AFNI_yesenv("AFNI_KEEP_PANNING") ){
04757              seq->zoom_button1 = 0 ;
04758              POPUP_cursorize( seq->wimage ) ;
04759              MCW_invert_widget( seq->zoom_drag_pb ) ;
04760            } else if( !seq->zoom_button1 ){           /* 23 Oct 2003 */
04761              if( seq->cmap_changed ){
04762                COLORMAP_CHANGE(seq); seq->cmap_changed = 0;
04763                if( seq->graymap_mtd != NULL && AFNI_yesenv("AFNI_STROKE_AUTOPLOT") ){
04764                  RWC_sleep(456) ;     /* pop down after a short delay */
04765                  plotkill_topshell( seq->graymap_mtd ) ;
04766                  seq->graymap_mtd = NULL ;
04767                }
04768              } else if( seq->status->send_CB != NULL ){  /* 04 Nov 2003 */
04769                 int imx,imy,nim;
04770                 seq->wimage_width = -1 ;
04771                 ISQ_mapxy( seq , seq->last_bx,seq->last_by , &imx,&imy,&nim ) ;
04772                 cbs.reason = isqCR_buttonpress ;
04773                 cbs.event  = ev ;
04774                 cbs.xim    = imx ;       /* delayed send of Button1 */
04775                 cbs.yim    = imy ;       /* event to AFNI now       */
04776                 cbs.nim    = nim ;
04777 #if 0
04778                 seq->status->send_CB( seq , seq->getaux , &cbs ) ;
04779 #else
04780                 SEND(seq,cbs) ;
04781 #endif
04782              }
04783            }
04784          }
04785       }
04786       break ;
04787 
04788       /*----- motion with Button #1 pressed down -----*/
04789 
04790       case MotionNotify:{
04791         XMotionEvent * event = (XMotionEvent *) ev ;
04792         int bx,by ;
04793 
04794         /** 03 Oct 2002: change Shift+Button1 into Button2, then send to that event handler **/
04795 
04796         if( (event->state & Button1Mask) &&
04797              ( seq->cursor_state == CURSOR_PENCIL ||
04798                ((event->state & ShiftMask) && !(event->state & ControlMask)) ) ){
04799           event->state |= Button2Mask ;
04800           if( seq->button2_enabled && w == seq->wimage )
04801              ISQ_button2_EV( w , client_data , ev , continue_to_dispatch ) ;
04802           else
04803              { XBell(seq->dc->display,100); busy=0;EXRETURN; }
04804           busy=0;EXRETURN ;
04805         }
04806 
04807         /* Button1 motion: if not panning, changing the color/gray map? */
04808 
04809         if( !seq->zoom_button1 && (event->state & Button1Mask) ){
04810           int xdif = (event->x - seq->last_bx) ;
04811           int ydif = (event->y - seq->last_by) ;
04812           if( !seq->dc->use_xcol_im && (xdif || ydif) ){
04813             double denom = AFNI_numenv("AFNI_STROKE_THRESHOLD") ;
04814             if( denom < 1.0l ){
04815               if( getenv("AFNI_STROKE_THRESHOLD") != NULL ){ busy=0;EXRETURN ;}
04816               denom = 32.0l ;
04817             }
04818             xdif = rint(xdif/denom) ; ydif = rint(ydif/denom) ;
04819             if( xdif || ydif ){                             /* if big enough change */
04820               if( seq->imim != NULL && seq->imim->kind == MRI_rgb ){ /* 26 Apr 2005 */
04821 
04822                      if( xdif > 0 ) seq->rgb_gamma  *= 0.95 ;  /* change the RGB */
04823                 else if( xdif < 0 ) seq->rgb_gamma  /= 0.95 ;      /* colorizing */
04824                      if( ydif < 0 ) seq->rgb_offset += 0.014;
04825                 else if( ydif > 0 ) seq->rgb_offset -= 0.014;
04826                 ISQ_redisplay( seq , -1 , isqDR_reimage ) ;
04827                 seq->cmap_changed = 1 ;
04828                 seq->last_bx=event->x ; seq->last_by=event->y;
04829 
04830               } else {                          /* the old way: change the gray map */
04831 
04832                 if( xdif ){ DC_gray_conbrio(seq->dc, xdif); seq->last_bx=event->x;}
04833                 if( ydif ){ DC_gray_change (seq->dc,-ydif); seq->last_by=event->y;}
04834                 seq->cmap_changed = 1 ;
04835                 if( seq->dc->visual_class == TrueColor ){
04836                   if( seq->graymap_mtd == NULL &&
04837                       AFNI_yesenv("AFNI_STROKE_AUTOPLOT") ) ISQ_graymap_draw( seq ) ;
04838                   KILL_2XIM( seq->given_xbar , seq->sized_xbar ) ;
04839                   ISQ_redisplay( seq , -1 , isqDR_display ) ;
04840                 } else {
04841                   if( seq->graymap_mtd != NULL ) ISQ_graymap_draw( seq ) ;
04842                 }
04843               }
04844             }
04845           }
04846           busy=0; EXRETURN ;
04847         }  /* end of altering colormap */
04848 
04849         /* Button1 motion: check for being in zoom-pan mode */
04850 
04851         if( !seq->zoom_button1              ||
04852             seq->zoom_fac == 1              ||
04853             seq->zoom_xim == NULL           ||
04854             (event->state & Button1Mask)==0   ){ busy=0; EXRETURN; } /* not zoom-pan? */
04855 
04856         /*-- if here, change panning offset --*/
04857 
04858         bx = event->x ; by = event->y ;
04859         ISQ_actually_pan( seq , (bx>seq->zoom_xp) ? -1
04860                                :(bx<seq->zoom_xp) ?  1 : 0 ,
04861                                 (by>seq->zoom_yp) ? -1
04862                                :(by<seq->zoom_yp) ?  1 : 0   ) ;
04863 
04864         seq->zoom_xp = bx ; seq->zoom_yp = by ;
04865 
04866         busy=0; EXRETURN ;
04867       }
04868       break ;
04869 
04870       /*----- redraw -----*/
04871 
04872       case Expose:{
04873          XExposeEvent * event = (XExposeEvent *) ev ;
04874 
04875 DPRI(" .. Expose; count=",event->count) ;
04876 
04877          XSync( XtDisplay(w) , False ) ;
04878          if( event->count == 0 ){      /* don't bother if more Expose to come */
04879             if( w == seq->wimage ){    /* 25 Sep 2000: check for hidden resizes */
04880                int nx,ny ;
04881                MCW_widget_geom( seq->wimage , &nx , &ny , NULL,NULL ) ;
04882 
04883                if( seq->sized_xim != NULL &&
04884                    ( (nx != seq->sized_xim->width ) ||
04885                      (ny != seq->sized_xim->height)   ) ){  /* found a hidden resize */
04886                                                             /* so let's un-hide it! */
04887                   XConfigureEvent nev ;
04888 
04889 DPR(" .. really a hidden resize") ;
04890 
04891                   nev.type = ConfigureNotify ; nev.width = nx ; nev.height = ny ;
04892                   ISQ_drawing_EV( w, client_data, (XEvent *) &nev, continue_to_dispatch ) ;
04893 
04894                } else
04895                   ISQ_show_image( seq ) ;
04896             }
04897             else if( w == seq->wbar )
04898                ISQ_show_bar( seq ) ;
04899 
04900          }
04901       }
04902       break ;
04903 
04904       /*----- take key press -----*/
04905 
04906       case KeyPress:{
04907          XKeyEvent *event = (XKeyEvent *) ev ;
04908          char       buf[32] ;
04909          int        nbuf ;
04910          KeySym     ks ;
04911 
04912 DPR(" .. KeyPress") ;
04913 
04914          ISQ_timer_stop(seq) ;  /* 03 Dec 2003 */
04915 
04916          /* discard if a mouse button is also pressed at this time */
04917 
04918          if( event->state & (Button1Mask|Button2Mask|Button3Mask) ){
04919            XBell(seq->dc->display,100); busy=0; EXRETURN;
04920          }
04921 
04922          /* get the string corresponding to the key pressed */
04923 
04924          buf[0] = '\0' ;
04925          ks     = 0 ;
04926          nbuf = XLookupString( event , buf , 32 , &ks , NULL ) ;
04927 #if 0
04928 fprintf(stderr,"KeySym=%04x nbuf=%d\n",(unsigned int)ks,nbuf) ;
04929 #endif
04930 
04931          /* 24 Jan 2003: deal with special function keys */
04932 
04933          if( nbuf == 0 || ks > 255 ){
04934            if( seq->record_mode ){ busy=0; EXRETURN ; }
04935            nbuf = ISQ_handle_keypress( seq , (unsigned long)ks ) ;
04936            busy=0; EXRETURN ;
04937          }
04938 
04939          nbuf = ISQ_handle_keypress( seq , (unsigned long)buf[0] ) ;
04940          if( nbuf ){ busy=0; EXRETURN; }
04941 
04942          /* in special modes (record, Button2, zoom-pan) mode, this is bad */
04943 
04944          if( seq->record_mode || seq->button2_active || seq->zoom_button1 ){
04945            XBell(seq->dc->display,100); busy=0; EXRETURN;
04946          }
04947 
04948          /* otherwise, notify the master, if we have one */
04949 
04950          if( w == seq->wimage && seq->status->send_CB != NULL ){
04951            cbs.reason = isqCR_keypress ;
04952            cbs.event  = ev ;
04953            cbs.key    = buf[0] ;
04954            cbs.nim    = seq->im_nr ;
04955 #if 0
04956            seq->status->send_CB( seq , seq->getaux , &cbs ) ;
04957 #else
04958            SEND(seq,cbs) ;
04959 #endif
04960          }
04961       }
04962       break ;  /* end of KeyPress */
04963 
04964       /*----- take button press -----*/
04965 
04966       case ButtonPress:{
04967          XButtonEvent * event = (XButtonEvent *) ev ;
04968          int bx,by , width,height , but ;
04969 
04970 DPR(" .. ButtonPress") ;
04971 
04972          /* don't allow button presses in a recorder window, or in zoom-pan mode */
04973 
04974          if( seq->record_mode || seq->zoom_button1 ){
04975            if( seq->record_mode || event->button != Button1 ) XBell(seq->dc->display,100);
04976            busy=0; EXRETURN;
04977          }
04978 
04979          /* button press in the wbar => popup menu */
04980 
04981          if( w == seq->wbar ){          /* moved here 18 Oct 2001 */
04982            if( event->button == Button1 ){ /* 21 Oct 2003 */
04983              bx = seq->opt.free_aspect ; seq->opt.free_aspect = 0 ;
04984              ISQ_reset_dimen( seq, seq->last_width_mm, seq->last_height_mm ) ;
04985              seq->opt.free_aspect = bx ;
04986            } else if( event->button == Button3 ){
04987              XmMenuPosition( seq->wbar_menu , event ) ; /* where */
04988              XtManageChild ( seq->wbar_menu ) ;         /* popup */
04989            }
04990            else
04991 #if 0
04992              XUngrabPointer( event->display , CurrentTime ) ;
04993 #else
04994              XBell(seq->dc->display,100) ;
04995 #endif
04996            busy=0; EXRETURN ;
04997          }
04998 
04999          /* below here, button press was in the image */
05000 
05001          seq->last_bx = bx = event->x ;  /* 23 Oct 2003: save last button */
05002          seq->last_by = by = event->y ;  /*            press (x,y) coords */
05003          seq->cmap_changed = 0 ;
05004          but = event->button ;
05005 
05006          MCW_widget_geom( w , &width , &height , NULL,NULL ) ;
05007          seq->wimage_width  = width ;
05008          seq->wimage_height = height ;
05009 
05010          MCW_discard_events( w , ButtonPressMask ) ;
05011 
05012          /* 12-17 Jun 2002: Shift+Button2 for picking crop rectangle */
05013 
05014          if( w == seq->wimage &&
05015              ( (but==Button2 && (event->state & ShiftMask)) ||
05016                (seq->crop_drag)                            )  ){
05017 
05018            ISQ_cropper( seq , event ) ;
05019            busy=0; EXRETURN ;
05020 
05021          } /* end of cropping stuff */
05022 
05023          /** 03 Oct 2002: change Shift+Button1 into Button2 **/
05024 
05025          if( but == Button1 &&
05026              ( seq->cursor_state == CURSOR_PENCIL ||
05027                ((event->state & ShiftMask) && !(event->state & ControlMask)) ) )
05028            event->button = but = Button2 ;
05029 
05030          /*-- default processing --*/
05031 
05032          switch( but ){
05033 
05034             case Button3:
05035             case Button1:{
05036               int imx,imy,nim;
05037 
05038               /* while Button2 is active, nothing else is allowed */
05039 
05040               if( seq->button2_active ){
05041                 /*** XBell(seq->dc->display,100) ; ***/
05042                 busy=0; EXRETURN ;
05043               }
05044 
05045               /* Button3 presses in the image with a modifier
05046                  key pressed also means to popup some menu    */
05047 
05048               if( w == seq->wimage && but == Button3 &&
05049                   (event->state & (ShiftMask|ControlMask|Mod1Mask)) ){
05050 
05051                 /* 23 Oct 1996: Simulation of bottom buttons */
05052 
05053                 if( (event->state & ShiftMask) && !(event->state & ControlMask) )
05054                   ISQ_but_disp_CB( seq->wbut_bot[NBUT_DISP] , seq , NULL ) ;
05055 
05056                 else if( (event->state & ControlMask) ){
05057                   if( seq->status->num_total > 1 && !(event->state & ShiftMask) ){
05058                     ISQ_montage_CB( seq->wbut_bot[NBUT_MONT] , seq , NULL ) ;
05059                   } else {
05060                     XmMenuPosition( seq->wbar_menu , event ) ;
05061                     XtManageChild ( seq->wbar_menu ) ;
05062                   }
05063                 }
05064 
05065                 else if( (seq->opt.save_one || seq->status->num_total > 1)
05066                          && (event->state & Mod1Mask) )
05067                    ISQ_but_save_CB( seq->wbut_bot[NBUT_SAVE] , seq , NULL ) ;
05068 
05069                 else
05070                    XBell( seq->dc->display , 100 ) ;
05071 
05072               /* compute the location in the image
05073                  where the button event transpired, and send to AFNI */
05074 
05075               } else if( w == seq->wimage && seq->status->send_CB != NULL ){
05076 
05077                 seq->wimage_width = -1 ;
05078                 ISQ_mapxy( seq , bx,by , &imx,&imy,&nim ) ;
05079                 cbs.reason = isqCR_buttonpress ;
05080                 cbs.event  = ev ;
05081                 cbs.xim    = imx ;
05082                 cbs.yim    = imy ;
05083                 cbs.nim    = nim ;
05084 
05085                 if( but == Button1 &&
05086                     (event->state & ControlMask) ){ /* 18 Oct 2001 */
05087                    event->button = Button3 ;        /* fake Button3 press */
05088                 }
05089 
05090                 if( event->button == Button3 )      /* 04 Nov 2003: only for Button3 */
05091 #if 0
05092                   seq->status->send_CB( seq , seq->getaux , &cbs ) ;
05093 #else
05094                   SEND(seq,cbs) ;
05095 #endif
05096               }
05097             }
05098             break ;
05099 
05100             /* pass this event to the separate handler, if allowed */
05101 
05102             case Button2:{
05103 
05104               /* drawing mode */
05105 
05106               if( seq->button2_enabled && w == seq->wimage )
05107                  ISQ_button2_EV( w , client_data , ev , continue_to_dispatch ) ;
05108               else
05109                  { XBell(seq->dc->display,100); busy=0; EXRETURN; }
05110             }
05111             break ;
05112 
05113             default: break ;
05114          }
05115       }
05116       ISQ_but_done_reset( seq ) ;
05117       break ;
05118 
05119       /*----- window changed size -----*/
05120 
05121       case ConfigureNotify:{
05122          XConfigureEvent * event = (XConfigureEvent *) ev ;
05123 
05124          static int am_active = 0  ;  /* 09 Oct 1999 */
05125 
05126 #if 0
05127          /* 04 Nov 2003: don't do anything while mouse is down */
05128          /* [doesn't work well - usually prevents anything at all] */
05129 
05130          { Window rW,cW ; int rx,ry,x,y ; unsigned int mask ;
05131            XQueryPointer(XtDisplay(w),XtWindow(w),&rW,&cW,&rx,&ry,&x,&y,&mask) ;
05132            if( mask & (Button1Mask|Button2Mask|Button3Mask) ) break ;
05133          }
05134 #endif
05135 
05136          if( am_active ) break ;      /* prevent recursion */
05137          am_active = 1 ;
05138 
05139  if(PRINT_TRACING){
05140   char str[256] ;
05141   sprintf(str," .. ConfigureNotify: width=%d height=%d",
05142           event->width,event->height);
05143   STATUS(str) ;
05144  }
05145 
05146          /* simply delete the XImage sized to the window;
05147             redisplay will then automatically size it when called */
05148 
05149          if( w == seq->wimage ){
05150 
05151             if( (seq->sized_xim == NULL)                  ||
05152                 (event->width  != seq->sized_xim->width ) ||
05153                 (event->height != seq->sized_xim->height)   ){
05154 
05155                seq->wimage_width = seq->wimage_height = -1 ; /* Feb 1998 */
05156 
05157                KILL_2ndXIM( seq->given_xim , seq->sized_xim ) ;
05158 
05159                /*-- 09 Oct 1999: if ordered, enforce aspect --*/
05160                /*-- 21 Oct 2003: only if it's been a while  --*/
05161 
05162 #if 0
05163 fprintf(stderr,"ConfigureNotify: width=%d height=%d\n",event->width,event->height);
05164 #endif
05165 
05166                if( AFNI_yesenv("AFNI_ENFORCE_ASPECT") && !seq->opt.free_aspect ){
05167                  static int last_time=0 ; int now_time=NI_clock_time() ;
05168                  if( now_time == 0 || now_time-last_time > 33 )
05169                    ISQ_reset_dimen( seq, seq->last_width_mm, seq->last_height_mm ) ;
05170 #if 0
05171 else fprintf(stderr,"  -- too soon to enforce aspect!\n") ;
05172 #endif
05173                  last_time = now_time ;
05174                }
05175 
05176                /*-- now show the image in the new window size --*/
05177 
05178                ISQ_show_image( seq ) ;
05179             }
05180 
05181          } else if( w == seq->wbar ){
05182 
05183              if( (seq->sized_xbar == NULL)                  ||
05184                  (event->width  != seq->sized_xbar->width ) ||
05185                  (event->height != seq->sized_xbar->height)   ){
05186 
05187                KILL_2ndXIM( seq->given_xbar , seq->sized_xbar ) ;
05188                ISQ_show_bar( seq ) ;
05189             }
05190          }
05191 
05192          am_active = 0 ;
05193       }
05194       break ;
05195 
05196       /*----- ignore all other events -----*/
05197 
05198       default: break ;
05199 
05200    } /* end of switch ev->type */
05201 
05202    busy=0; EXRETURN ;
05203 }