do{ XtPointer (*gs)(int,int,XtPointer) =                       \
      (XtPointer (*)(int,int,XtPointer))(gr->getser) ;          \
    rval = (rtyp) gs(aa,bb,gr->getaux) ;                        \
 } while(0)

do{ void (*sb)(MCW_grapher *,XtPointer,GRA_cbs *) =                          \
      (void (*)(MCW_grapher *,XtPointer,GRA_cbs *))(gr->status->send_CB) ;    \
     if( sb != NULL ) sb(gr,gr->getaux,&scb) ;                                \
 } while(0)

fmenu -> wname =                                                \
         XtVaCreateManagedWidget(                                  \
            "dialog" , xmPushButtonWidgetClass , fmenu->fim_menu , \
               LABEL_ARG( label ) ,                                \
               XmNmarginHeight , 0 ,                               \
               XmNtraversalOn , False ,                            \
               XmNinitialResourcesPersistent , False ,             \
            NULL ) ;                                               \
      XtAddCallback( fmenu -> wname , XmNactivateCallback ,        \
                     cbfunc , (XtPointer) fmenu ) ;                \
      MCW_register_hint( fmenu -> wname , hhh ) ;

fmenu -> wname =                                               \
         XtVaCreateManagedWidget(                                 \
            "dialog" , xmPushButtonWidgetClass , fmenu -> wmenu , \
               LABEL_ARG( label ) ,                               \
               XmNmarginHeight , 0 ,                              \
               XmNtraversalOn , False ,                           \
               XmNinitialResourcesPersistent , False ,            \
            NULL ) ;                                              \
      XtAddCallback( fmenu -> wname , XmNactivateCallback ,       \
                     cbfunc , (XtPointer) fmenu ) ;               \
      MCW_register_hint( fmenu -> wname , hhh ) ;

fmenu -> wmenu =                                                \
     XmCreatePulldownMenu( fmenu->fim_menu , "menu" , NULL , 0 ) ; \
   fmenu -> wcbut =                                                \
     XtVaCreateManagedWidget(                                      \
       "dialog" , xmCascadeButtonWidgetClass , fmenu->fim_menu ,   \
          LABEL_ARG( label ) ,                                     \
          XmNsubMenuId , fmenu -> wmenu ,                          \
          XmNtraversalOn , False ,                                 \
          XmNinitialResourcesPersistent , False ,                  \
       NULL ) ;                                                    \
   MCW_register_hint( fmenu -> wcbut , hhh ) ;                     \
   XtAddCallback( fmenu -> wmenu, XmNmapCallback, GRA_mapmenu_CB, NULL ) ;

do { Widget ccc ;                                                        \
      qbut_menu = XmCreatePulldownMenu(fmenu->fim_menu,"menu",NULL,0);    \
            ccc = XtVaCreateManagedWidget( "dialog" ,                     \
                     xmCascadeButtonWidgetClass , fmenu->fim_menu ,       \
                     LABEL_ARG( label ) ,                                 \
                     XmNsubMenuId , qbut_menu ,                           \
                     XmNtraversalOn , False ,                             \
                     XmNinitialResourcesPersistent , False , NULL ) ;     \
      fmenu -> wname = XtVaCreateManagedWidget( "dialog" ,                \
                         xmPushButtonWidgetClass , qbut_menu ,            \
                         LABEL_ARG( qlab ) ,                              \
                         XmNmarginHeight , 0 ,                            \
                         XmNtraversalOn , False ,                         \
                         XmNinitialResourcesPersistent , False , NULL ) ; \
      MCW_register_hint( fmenu -> wname , hhh ) ;                         \
      XtAddCallback( fmenu -> wname , XmNactivateCallback ,               \
                     cbfunc , (XtPointer) fmenu ) ;                       \
      XtAddCallback( qbut_menu, XmNmapCallback, GRA_mapmenu_CB, NULL ) ;  \
 } while(0)

(void) XtVaCreateManagedWidget(                               \
            "dialog" , xmSeparatorWidgetClass , fmenu -> wmenu , \
             XmNseparatorType , XmDOUBLE_LINE , NULL )

(void) XtVaCreateManagedWidget(                                 \
            "dialog" , xmSeparatorWidgetClass , grapher -> wmenu , \
             XmNseparatorType , XmDOUBLE_LINE , NULL )

(void) XtVaCreateManagedWidget(                               \
            "dialog" , xmSeparatorWidgetClass , fmenu -> wmenu , \
             XmNseparatorType , XmSINGLE_LINE , NULL )

(void) XtVaCreateManagedWidget(                                 \
            "dialog" , xmSeparatorWidgetClass , grapher -> wmenu , \
             XmNseparatorType , XmSINGLE_LINE , NULL )

grapher -> wname =                                                \
         XtVaCreateManagedWidget(                                    \
            "dialog" , xmPushButtonWidgetClass , grapher->opt_menu , \
               LABEL_ARG( label ) ,                                  \
               XmNmarginHeight , 0 ,                                 \
               XmNtraversalOn , False ,                              \
               XmNinitialResourcesPersistent , False ,               \
            NULL ) ;                                                 \
      XtAddCallback( grapher -> wname , XmNactivateCallback ,        \
                     GRA_opt_CB , (XtPointer) grapher ) ;            \
      MCW_register_hint( grapher -> wname , hhh ) ;

grapher -> wname =                                               \
      new_MCW_optmenu( grapher -> wmenu , label , 0,1,0,0 ,         \
                       cb , (XtPointer) grapher , NULL , NULL ) ;   \
   MCW_reghint_children( grapher -> wname -> wrowcol , hhh ) ;

grapher -> wname =                                               \
         XtVaCreateManagedWidget(                                   \
            "dialog" , xmPushButtonWidgetClass , grapher -> wmenu , \
               LABEL_ARG( label ) ,                                 \
               XmNmarginHeight , 0 ,                                \
               XmNtraversalOn , False ,                             \
               XmNinitialResourcesPersistent , False ,              \
            NULL ) ;                                                \
      XtAddCallback( grapher -> wname , XmNactivateCallback ,       \
                     GRA_opt_CB , (XtPointer) grapher ) ;           \
   MCW_register_hint( grapher -> wname , hhh ) ;

grapher -> wmenu =                                                  \
     XmCreatePulldownMenu( grapher->opt_menu , "menu" , NULL , 0 ) ;   \
   grapher -> wcbut =                                                  \
     XtVaCreateManagedWidget(                                          \
       "dialog" , xmCascadeButtonWidgetClass , grapher->opt_menu ,     \
          LABEL_ARG( label ) ,                                         \
          XmNsubMenuId , grapher -> wmenu ,                            \
          XmNtraversalOn , False ,                                     \
          XmNinitialResourcesPersistent , False ,                      \
       NULL ) ;                                                        \
   MCW_register_hint( grapher -> wcbut , hhh ) ;                       \
   XtAddCallback( grapher -> wmenu, XmNmapCallback, GRA_mapmenu_CB, NULL ) ;

( (grapher->xax_tsim != NULL && (ii) < grapher->xax_tsim->nx)        \
     ? (MRI_FLOAT_PTR(grapher->xax_tsim)[MAX((ii),ibot)] * grapher->gx) \
     : (((ii)-pbot) * ftemp) )

05113 {
05114    FIM_menu *fmenu ;
05115    Widget qbut_menu = NULL ;
05116 
05117 ENTRY("AFNI_new_fim_menu") ;
05118 
05119    fmenu = myXtNew(FIM_menu) ;
05120    fmenu->cbfunc = cbfunc ;
05121 
05122    /*------------------------*/
05123    /*--- FIM Menu Buttons ---*/
05124    /*------------------------*/
05125 
05126    fmenu->fim_menu =
05127          XmCreatePulldownMenu( parent , "menu" , NULL,0 ) ;
05128 
05129    VISIBILIZE_WHEN_MAPPED(fmenu->fim_menu) ;  /* 27 Sep 2000 */
05130 
05131    fmenu->fim_cbut =
05132          XtVaCreateManagedWidget(
05133             "dialog" , xmCascadeButtonWidgetClass , parent ,
05134                LABEL_ARG("FIM") ,
05135                XmNsubMenuId , fmenu->fim_menu ,
05136                XmNmarginWidth  , 0 ,
05137                XmNmarginHeight , 0 ,
05138                XmNmarginBottom , 0 ,
05139                XmNmarginTop    , 0 ,
05140                XmNmarginRight  , 0 ,
05141                XmNmarginLeft   , 0 ,
05142                XmNtraversalOn  , False ,
05143                XmNinitialResourcesPersistent , False ,
05144             NULL ) ;
05145 
05146    if( graphable ){
05147       MCW_register_hint( fmenu->fim_cbut , "Functional Imaging menu" ) ;
05148       MCW_register_help( fmenu->fim_cbut ,
05149                       "*******  Functional Imaging Controls:  *******\n"
05150                       "\n"
05151                       "Ideal Vector Operations:\n"
05152                       " Pick Ideal --> Choose from a list\n"
05153                       " Pick Ort   --> Choose from a list\n"
05154                       " Edit: = Center --> Use voxel timeseries\n"
05155                       "      += Center --> Average with voxel\n"
05156                       "      Smooth    --> A 3 point filter\n"
05157                       "      Shift     --> Time-shifted copies\n"
05158                       "      Clear     --> Turn ideal off\n"
05159                       "      WinAver   --> Average of sub-graphs\n"
05160                       "      Read      --> Input from external file\n"
05161                       "      Write     --> Output to external file\n"
05162                       "      Store     --> Save in internal list\n"
05163                       " Ignore: Set how many points to ignore\n"
05164                       "         at beginning of time series\n"
05165                       "         [ Applies both to graphing ]\n"
05166                       "         [ and to FIM computations. ]\n"
05167                       "\n"
05168                       "FIM Plots:\n"
05169                       "  Can choose to graph only first vector in\n"
05170                       "  ideal family, or all of them superimposed.\n"
05171                       "\n"
05172                       "Refresh Freq --> Choose number of time steps\n"
05173                       "   between redisplay of the functional overlay\n"
05174                       "   during FIM computations (0 == no redisplay).\n"
05175                       "Compute FIM  --> Use the recursive method to\n"
05176                       "   compute the correlation of each voxel time\n"
05177                       "   series with each ideal vector;  uses the best\n"
05178                       "   correlation as the 'correct' waveform for\n"
05179                       "   each voxel, individually.  Time points that\n"
05180                       "   have an ideal vector value >= 33333 will be\n"
05181                       "   ignored in the computations, as will those\n"
05182                       "   at the beginning specified in the Opt menu\n"
05183                       "   'Ignore' function."
05184                     ) ;
05185    } else {
05186       MCW_register_hint( fmenu->fim_cbut , "Functional Imaging menu" ) ;
05187       MCW_register_help( fmenu->fim_cbut ,
05188                       "*******  Functional Imaging Controls:  *******\n"
05189                       "\n"
05190                       "Pick Dataset --> Choose time-dependent dataset\n"
05191                       "   from a list.  If there is only one possible\n"
05192                       "   choice, it will be selected for you without\n"
05193                       "   displaying the list.\n"
05194                       "\n"
05195                       "Pick Ideal --> Choose time series from a list.\n"
05196                       "Pick Ort   --> Choose time series from a list.\n"
05197                       "\n"
05198                       "Ignore --> Set how many points to ignore at the\n"
05199                       "   beginning of time series.\n"
05200                       "   [ Applies both to graphing and FIM-ing. ]\n"
05201                       "\n"
05202                       "Refresh Freq --> Choose number of time steps\n"
05203                       "   between redisplay of the functional overlay\n"
05204                       "   during FIM computations (0 == no redisplay).\n"
05205                       "\n"
05206                       "Compute FIM --> Use the recursive method to\n"
05207                       "   compute the correlation of each voxel time\n"
05208                       "   series with each ideal vector;  uses the best\n"
05209                       "   correlation as the 'correct' waveform for\n"
05210                       "   each voxel, individually.  Time points that\n"
05211                       "   have an ideal vector value >= 33333 will be\n"
05212                       "   ignored in the computations, as will those\n"
05213                       "   at the beginning specified in the Opt menu\n"
05214                       "   'Ignore' function."
05215                     ) ;
05216    }
05217 
05218    /* macros to put double and single separator lines in a menu */
05219 
05220 #undef MENU_DLINE
05221 #define MENU_DLINE(wmenu)                                        \
05222    (void) XtVaCreateManagedWidget(                               \
05223             "dialog" , xmSeparatorWidgetClass , fmenu -> wmenu , \
05224              XmNseparatorType , XmDOUBLE_LINE , NULL )
05225 
05226 #undef MENU_SLINE
05227 #define MENU_SLINE(wmenu)                                        \
05228    (void) XtVaCreateManagedWidget(                               \
05229             "dialog" , xmSeparatorWidgetClass , fmenu -> wmenu , \
05230              XmNseparatorType , XmSINGLE_LINE , NULL )
05231 
05232    /* macro to create a new FIM menu button */
05233 
05234 #define FIM_MENU_BUT(wname,label,hhh)                              \
05235    fmenu -> wname =                                                \
05236          XtVaCreateManagedWidget(                                  \
05237             "dialog" , xmPushButtonWidgetClass , fmenu->fim_menu , \
05238                LABEL_ARG( label ) ,                                \
05239                XmNmarginHeight , 0 ,                               \
05240                XmNtraversalOn , False ,                            \
05241                XmNinitialResourcesPersistent , False ,             \
05242             NULL ) ;                                               \
05243       XtAddCallback( fmenu -> wname , XmNactivateCallback ,        \
05244                      cbfunc , (XtPointer) fmenu ) ;                \
05245       MCW_register_hint( fmenu -> wname , hhh ) ;
05246 
05247    /** macro to create a new fim pullright menu **/
05248    /** 07 Jan 1999: added the mapCallback to fix position **/
05249 
05250 #define FIM_MENU_PULLRIGHT(wmenu,wcbut,label,hhh)                  \
05251    fmenu -> wmenu =                                                \
05252      XmCreatePulldownMenu( fmenu->fim_menu , "menu" , NULL , 0 ) ; \
05253    fmenu -> wcbut =                                                \
05254      XtVaCreateManagedWidget(                                      \
05255        "dialog" , xmCascadeButtonWidgetClass , fmenu->fim_menu ,   \
05256           LABEL_ARG( label ) ,                                     \
05257           XmNsubMenuId , fmenu -> wmenu ,                          \
05258           XmNtraversalOn , False ,                                 \
05259           XmNinitialResourcesPersistent , False ,                  \
05260        NULL ) ;                                                    \
05261    MCW_register_hint( fmenu -> wcbut , hhh ) ;                     \
05262    XtAddCallback( fmenu -> wmenu, XmNmapCallback, GRA_mapmenu_CB, NULL ) ;
05263 
05264    /** macro to create a new button on a pullright menu **/
05265 
05266 #define FIM_MENU_PULL_BUT(wmenu,wname,label,hhh)                  \
05267    fmenu -> wname =                                               \
05268          XtVaCreateManagedWidget(                                 \
05269             "dialog" , xmPushButtonWidgetClass , fmenu -> wmenu , \
05270                LABEL_ARG( label ) ,                               \
05271                XmNmarginHeight , 0 ,                              \
05272                XmNtraversalOn , False ,                           \
05273                XmNinitialResourcesPersistent , False ,            \
05274             NULL ) ;                                              \
05275       XtAddCallback( fmenu -> wname , XmNactivateCallback ,       \
05276                      cbfunc , (XtPointer) fmenu ) ;               \
05277       MCW_register_hint( fmenu -> wname , hhh ) ;
05278 
05279 #define EMPTY_BUT(wname) fmenu -> wname = NULL
05280 
05281    /** 15 Dec 1997: a pullright menu with a single button **/
05282 
05283 #define FIM_MENU_QBUT(wname,label,qlab,hhh)                               \
05284  do { Widget ccc ;                                                        \
05285       qbut_menu = XmCreatePulldownMenu(fmenu->fim_menu,"menu",NULL,0);    \
05286             ccc = XtVaCreateManagedWidget( "dialog" ,                     \
05287                      xmCascadeButtonWidgetClass , fmenu->fim_menu ,       \
05288                      LABEL_ARG( label ) ,                                 \
05289                      XmNsubMenuId , qbut_menu ,                           \
05290                      XmNtraversalOn , False ,                             \
05291                      XmNinitialResourcesPersistent , False , NULL ) ;     \
05292       fmenu -> wname = XtVaCreateManagedWidget( "dialog" ,                \
05293                          xmPushButtonWidgetClass , qbut_menu ,            \
05294                          LABEL_ARG( qlab ) ,                              \
05295                          XmNmarginHeight , 0 ,                            \
05296                          XmNtraversalOn , False ,                         \
05297                          XmNinitialResourcesPersistent , False , NULL ) ; \
05298       MCW_register_hint( fmenu -> wname , hhh ) ;                         \
05299       XtAddCallback( fmenu -> wname , XmNactivateCallback ,               \
05300                      cbfunc , (XtPointer) fmenu ) ;                       \
05301       XtAddCallback( qbut_menu, XmNmapCallback, GRA_mapmenu_CB, NULL ) ;  \
05302  } while(0)
05303 
05304    /*** top of menu = a label to click on that does nothing at all ***/
05305 
05306    (void) XtVaCreateManagedWidget(
05307             "dialog" , xmLabelWidgetClass , fmenu->fim_menu ,
05308                LABEL_ARG("--- Cancel ---") ,
05309                XmNrecomputeSize , False ,
05310                XmNinitialResourcesPersistent , False ,
05311             NULL ) ;
05312 
05313    MENU_SLINE(fim_menu) ;
05314 
05315    if( graphable ){
05316       EMPTY_BUT(fim_pickdset_pb) ;
05317    } else {
05318       FIM_MENU_BUT( fim_pickdset_pb , "Pick Dataset" , "Choose Dataset to Graph" ) ;
05319    }
05320 
05321    FIM_MENU_BUT( fim_pickref_pb , "Pick Ideal" , "Pick Ideal Timeseries to Graph" ) ;
05322    FIM_MENU_BUT( fim_pickort_pb , "Pick Ort"   , "Pick Ort Timeseries to Graph"   ) ;
05323 
05324    if( graphable ){
05325       char *bbox_label[1] = { "Ideal=WinAver" } ;
05326       MENU_SLINE(fim_menu) ;
05327       FIM_MENU_PULLRIGHT(fim_editref_menu,fim_editref_cbut       ,"Edit Ideal"    , "Modify Ideal Timeseries" ) ;
05328       FIM_MENU_PULL_BUT (fim_editref_menu,fim_editref_equals_pb  ,"Ideal = Center", "Set to Center Sub-graph" ) ;
05329       FIM_MENU_PULL_BUT (fim_editref_menu,fim_editref_add_pb     ,"Ideal+= Center", "Add in Center Sub-graph" ) ;
05330       FIM_MENU_PULL_BUT (fim_editref_menu,fim_editref_smooth_pb  ,"Smooth Ideal"  , "Lowpass Filter Ideal"    ) ;
05331       FIM_MENU_PULL_BUT (fim_editref_menu,fim_editref_setshift_pb,"Shift Ideal"   , "Time Shift Ideal"        ) ;
05332       FIM_MENU_PULL_BUT (fim_editref_menu,fim_editref_clear_pb   ,"Clear Ideal"   , "Turn Ideal Off"          ) ;
05333       FIM_MENU_PULL_BUT (fim_editref_menu,fim_editort_clear_pb   ,"Clear Ort"     , "Turn Ort Off"            ) ;
05334 
05335       fmenu->fim_editref_winaver_bbox                      /* 27 Jan 2004 */
05336        = new_MCW_bbox( fmenu->fim_editref_menu ,
05337                        1 , bbox_label , MCW_BB_check , MCW_BB_noframe ,
05338                        GRA_winaver_CB , (XtPointer)fmenu ) ;
05339       MCW_reghint_children( fmenu->fim_editref_winaver_bbox->wrowcol ,
05340                             "Ideal = Average of all Graphs in Window" ) ;
05341 #ifdef USE_OPTMENUS
05342       fmenu->fim_polort_choose_av =
05343          new_MCW_optmenu( fmenu->fim_editref_menu , "Polort " , 0,MAX_POLORT,1,0 ,
05344                           GRA_fmenu_av_CB , (XtPointer) fmenu , NULL , NULL ) ;
05345       fmenu->fim_polort_choose_pb = fmenu->fim_polort_choose_av->wrowcol ;
05346       MCW_reghint_children( fmenu->fim_polort_choose_av->wrowcol , "Order of Polynomial Baseline for FIM" ) ;
05347 #else
05348       FIM_MENU_PULL_BUT( fim_editref_menu,fim_polort_choose_pb ,"Polort?", "Order of Polynomial Baseline for FIM") ;
05349 #endif
05350       FIM_MENU_PULL_BUT( fim_editref_menu,fim_bkthr_choose_pb  ,"Bkg Thresh" , "Choose Background Threshold for FIM") ;
05351       MENU_SLINE        (fim_editref_menu) ;
05352       FIM_MENU_PULL_BUT (fim_editref_menu,fim_editref_read_pb    ,"Read Ideal" , "Read from .1D file"   ) ;
05353       FIM_MENU_PULL_BUT (fim_editref_menu,fim_editref_write_pb   ,"Write Ideal", "Write to .1D file"    ) ;
05354       FIM_MENU_PULL_BUT (fim_editref_menu,fim_editref_store_pb   ,"Store Ideal", "Save in internal list of timeseries" ) ;
05355    } else {
05356       EMPTY_BUT(fim_editref_cbut) ;
05357       EMPTY_BUT(fim_editref_equals_pb) ;
05358       EMPTY_BUT(fim_editref_add_pb) ;
05359       EMPTY_BUT(fim_editref_smooth_pb) ;
05360       EMPTY_BUT(fim_editref_setshift_pb) ;
05361       EMPTY_BUT(fim_editref_clear_pb) ;
05362       EMPTY_BUT(fim_editref_read_pb) ;
05363       EMPTY_BUT(fim_editref_write_pb) ;
05364       EMPTY_BUT(fim_editref_store_pb) ;
05365       EMPTY_BUT(fim_editort_clear_pb) ;
05366       EMPTY_BUT(fim_polort_choose_pb) ;
05367       fmenu->fim_editref_winaver_bbox = NULL ;  /* 27 Jan 2004 */
05368    }
05369 
05370    FIM_MENU_PULLRIGHT(fim_ignore_menu,fim_ignore_cbut      ,"Ignore", "Number of initial timepoints to ignore" ) ;
05371    FIM_MENU_PULL_BUT( fim_ignore_menu,fim_ignore_down_pb   ,"Down"  , "Ignore fewer points" ) ;
05372    FIM_MENU_PULL_BUT( fim_ignore_menu,fim_ignore_up_pb     ,"Up"    , "Ignore more points"  ) ;
05373 #ifdef USE_OPTMENUS
05374    fmenu->fim_ignore_choose_av =
05375       new_MCW_optmenu( fmenu->fim_ignore_menu , "# " , 0,2,0,0 ,
05376                        GRA_fmenu_av_CB , (XtPointer) fmenu , NULL , NULL ) ;
05377    fmenu->fim_ignore_choose_pb = fmenu->fim_ignore_choose_av->wrowcol ;
05378    MCW_reghint_children( fmenu->fim_ignore_choose_av->wrowcol , "Pick number of ignored points" ) ;
05379 #else
05380    FIM_MENU_PULL_BUT( fim_ignore_menu,fim_ignore_choose_pb ,"Choose" , "Pick number of ignored points") ;
05381 #endif
05382 
05383    if( graphable ){
05384       FIM_MENU_PULLRIGHT(fim_plot_menu,fim_plot_cbut        ,"FIM Plots"   , "Number of Ideals to plot" ) ;
05385       FIM_MENU_PULL_BUT( fim_plot_menu,fim_plot_firstref_pb ,"First Ideal" , "Only plot 1 Ideal" ) ;
05386       FIM_MENU_PULL_BUT( fim_plot_menu,fim_plot_allrefs_pb  ,"All Ideals"  , "Plot all Ideals"   ) ;
05387    } else {
05388       EMPTY_BUT(fim_plot_cbut) ;
05389       EMPTY_BUT(fim_plot_firstref_pb) ;
05390       EMPTY_BUT(fim_plot_allrefs_pb) ;
05391    }
05392 
05393    MENU_DLINE(fim_menu) ;
05394    FIM_MENU_QBUT( fim_execute_pb   , "Compute FIM" , "-> fico" , "Correlation Analysis" ) ;
05395    MCW_set_widget_bg( fmenu->fim_execute_pb ,
05396                       MCW_hotcolor(fmenu->fim_execute_pb) , 0 ) ;
05397 
05398    { static char * blab[] = {"Fit Coef", "% Change", "% From Ave", "% From Top"};
05399      (void) XtVaCreateManagedWidget(
05400              "dialog" , xmSeparatorWidgetClass , qbut_menu ,
05401               XmNseparatorType , XmSINGLE_LINE , NULL ) ;
05402 
05403      fmenu->fim_opt_bbox = new_MCW_bbox( qbut_menu , 4 , blab ,
05404                                          MCW_BB_radio_one , MCW_BB_noframe ,
05405                                          NULL , NULL ) ;
05406      MCW_reghint_children( fmenu->fim_opt_bbox->wrowcol , "What to Compute" ) ;
05407    }
05408 
05409    MENU_DLINE(fim_menu) ;
05410    FIM_MENU_QBUT( fim_execfimp_pb  , "Compute FIM+" , "-> fbuc" , "Extended Correlation Analysis" ) ;
05411    MCW_set_widget_bg( fmenu->fim_execfimp_pb ,
05412                       MCW_hotcolor(fmenu->fim_execfimp_pb) , 0 ) ;
05413 
05414    (void) XtVaCreateManagedWidget(
05415            "dialog" , xmSeparatorWidgetClass , qbut_menu ,
05416             XmNseparatorType , XmSINGLE_LINE , NULL ) ;
05417 
05418    fmenu->fimp_opt_bbox = new_MCW_bbox( qbut_menu, FIM_NUM_OPTS, fim_opt_labels,
05419                                         MCW_BB_check , MCW_BB_noframe ,
05420                                         NULL , NULL ) ;
05421    MCW_reghint_children( fmenu->fimp_opt_bbox->wrowcol , "What to Compute" ) ;
05422 
05423    { char * ff = my_getenv( "AFNI_FIM_MASK" ) ; int mm=0 ;
05424      if( ff != NULL ) mm = strtol(ff,NULL,10) ;
05425      if( mm <= 0 ) mm = FIM_DEFAULT_MASK ;
05426      MCW_set_bbox( fmenu->fimp_opt_bbox , mm ) ;
05427    }
05428 
05429    /* 04 Jan 2000: add some more buttons */
05430 
05431    (void) XtVaCreateManagedWidget(
05432            "dialog" , xmSeparatorWidgetClass , qbut_menu ,
05433             XmNseparatorType , XmSINGLE_LINE , NULL ) ;
05434 
05435    fmenu->fimp_setdefault_pb =
05436       XtVaCreateManagedWidget( "dialog" , xmPushButtonWidgetClass , qbut_menu ,
05437                                  LABEL_ARG( "Set Defaults" ) ,
05438                                  XmNmarginHeight , 0 ,
05439                                  XmNtraversalOn , False ,
05440                                  XmNinitialResourcesPersistent , False ,
05441                                NULL ) ;
05442    XtAddCallback( fmenu->fimp_setdefault_pb ,
05443                   XmNactivateCallback , cbfunc , (XtPointer) fmenu ) ;
05444    MCW_register_hint( fmenu->fimp_setdefault_pb , "Default computing options" ) ;
05445 
05446    fmenu->fimp_setall_pb =
05447       XtVaCreateManagedWidget( "dialog" , xmPushButtonWidgetClass , qbut_menu ,
05448                                  LABEL_ARG( "Set All" ) ,
05449                                  XmNmarginHeight , 0 ,
05450                                  XmNtraversalOn , False ,
05451                                  XmNinitialResourcesPersistent , False ,
05452                                NULL ) ;
05453    XtAddCallback( fmenu->fimp_setall_pb ,
05454                   XmNactivateCallback , cbfunc , (XtPointer) fmenu ) ;
05455    MCW_register_hint( fmenu->fimp_setall_pb , "Set all computing options on" ) ;
05456 
05457    fmenu->fimp_unsetall_pb =
05458       XtVaCreateManagedWidget( "dialog" , xmPushButtonWidgetClass , qbut_menu ,
05459                                  LABEL_ARG( "Unset All" ) ,
05460                                  XmNmarginHeight , 0 ,
05461                                  XmNtraversalOn , False ,
05462                                  XmNinitialResourcesPersistent , False ,
05463                                NULL ) ;
05464    XtAddCallback( fmenu->fimp_unsetall_pb ,
05465                   XmNactivateCallback , cbfunc , (XtPointer) fmenu ) ;
05466    MCW_register_hint( fmenu->fimp_unsetall_pb , "Set all computing options off" ) ;
05467 
05468    /* 01 Feb 2000: add user-contributed options (if any) */
05469 
05470    fmenu->fimp_user_bbox = NULL ; /* default = no menu */
05471 
05472    if( GLOBAL_library.registered_fim.num > 0 ){
05473 
05474       (void) XtVaCreateManagedWidget(
05475               "dialog" , xmSeparatorWidgetClass , qbut_menu ,
05476                XmNseparatorType , XmDOUBLE_LINE , NULL ) ;
05477 
05478       (void) XtVaCreateManagedWidget(
05479                "dialog" , xmLabelWidgetClass , qbut_menu ,
05480                   LABEL_ARG("--Extra Funcs--") ,
05481                   XmNrecomputeSize , False ,
05482                   XmNinitialResourcesPersistent , False ,
05483                NULL ) ;
05484 
05485       fmenu->fimp_user_bbox = new_MCW_bbox( qbut_menu,
05486                                             GLOBAL_library.registered_fim.num ,
05487                                             GLOBAL_library.registered_fim.labels ,
05488                                             MCW_BB_check , MCW_BB_noframe ,
05489                                             NULL , NULL ) ;
05490       MCW_reghint_children( fmenu->fimp_user_bbox->wrowcol , "Other correlation functions" ) ;
05491    }
05492 
05493    RETURN(fmenu) ;
05494 }

01529 {
01530    int ii ;
01531    if( npoints < 2 ) return ;            /* 02 Apr 2004 */
01532    for( ii=GRID_MAX-1 ; ii > 0 ; ii-- )
01533      if( grid_ar[ii] <= npoints/3 ) break;
01534    grapher->grid_index   = ii ;
01535    grapher->grid_spacing = grid_ar[ii] ;
01536    grapher->grid_fixed   = 0 ;           /* 02 Apr 2004 */
01537    return ;
01538 }

02473 {
02474    int i , mat=grapher->mat , gx=grapher->gx , gy=grapher->gy ;
02475    int j, k, g, xo, yo, npoints , m ;
02476    int xc = grapher->xc , yc = grapher->yc ;
02477    float ftemp ;
02478 
02479 ENTRY("draw_grids") ;
02480    if( grapher->dont_redraw ) EXRETURN ;  /* 27 Jan 2004 */
02481 
02482    /* draw grid lines in the chosen color */
02483 
02484    if( GRID_COLOR(grapher) > 0 ){
02485       DC_fg_color ( grapher->dc , GRID_COLOR(grapher) ) ;
02486       DC_linewidth( grapher->dc , GRID_THICK(grapher) ) ;
02487 
02488       g       = grapher->grid_spacing ;
02489       npoints = NPTS(grapher) ;  /* number time points in 1 sub-graph window */
02490 
02491       if( npoints > 1 ){                /* this if: 22 Sep 2000 */
02492         ftemp = gx / (npoints-1.0) ;
02493         for( i=0 ; i < mat ; i++ ){
02494           for( m=0 ; m < mat ; m++ ){
02495             xo = grapher->xorigin[i][m] ; yo = grapher->yorigin[i][m] ;
02496             for( j=1 ; j <= (npoints-1)/g ; j++ ){
02497               k = xo + j * g * ftemp ;
02498               plot_fdX( grapher , k , yo    , 0 ) ;
02499               plot_fdX( grapher , k , yo+gy , 1 ) ;
02500             }
02501           }
02502         }
02503       }
02504 
02505       /* draw an interior framing box at the central square */
02506 
02507       xo = grapher->xorigin[xc][yc] ; yo = grapher->yorigin[xc][yc] ;
02508       g  = MIN( grapher->gy/3 , grapher->gx/3 ) ; g  = MIN( g , 4 ) ;
02509       for( j=1 ; j <= g ; j++ ){
02510          plot_fdX( grapher , xo+j    , yo+j    , 0 ) ;
02511          plot_fdX( grapher , xo+j    , yo+gy-j , 1 ) ;
02512          plot_fdX( grapher , xo+gx-j , yo+gy-j , 1 ) ;
02513          plot_fdX( grapher , xo+gx-j , yo+j    , 1 ) ;
02514          plot_fdX( grapher , xo+j    , yo+j    , 1 ) ;
02515       }
02516    }
02517 
02518    /* draw exterior frames */
02519 
02520    DC_fg_color ( grapher->dc , FG_COLOR(grapher) ) ;
02521    DC_linewidth( grapher->dc , FG_THICK(grapher) ) ;
02522 
02523    for( i=0 ; i < mat ; i++ ){
02524       for( j=0 ; j < mat ; j++ ){
02525          xo = grapher->xorigin[i][j] ; yo = grapher->yorigin[i][j] ;
02526          plot_fdX( grapher , xo    , yo    , 0 ) ;
02527          plot_fdX( grapher , xo+gx , yo    , 1 ) ;
02528          plot_fdX( grapher , xo+gx , yo+gy , 1 ) ;
02529          plot_fdX( grapher , xo    , yo+gy , 1 ) ;
02530          plot_fdX( grapher , xo    , yo    , 1 ) ;
02531       }
02532    }
02533 
02534    EXRETURN ;
02535 }

04127 {
04128 
04129 ENTRY("drive_MCW_grapher") ;
04130 
04131    if( ! GRA_VALID(grapher) ) RETURN(False) ;
04132 
04133    switch( drive_code ){
04134 
04135       /*------- error! -------*/
04136 
04137       default:{
04138          fprintf(stderr,"\a\n*** drive_MCW_grapher: code=%d illegal!\n",
04139                  drive_code) ;
04140          XBell( grapher->dc->display , 100 ) ;
04141          RETURN( False ) ;
04142       }
04143 
04144       /*------ winaver [27 Jan 2004] -----*/
04145 
04146       case graDR_winaver:{
04147         int vvv = (int)drive_data ;
04148         MCW_set_bbox( grapher->fmenu->fim_editref_winaver_bbox , vvv ) ;
04149         RETURN( True ) ;
04150       }
04151 
04152       /*------ setglobalbaseline [07 Aug 2001] -----*/
04153 
04154       case graDR_setglobalbaseline:{
04155          float *vvv = (float *) drive_data ;   /* get value   */
04156          int ii = thd_floatscan( 1 , vvv ) ;   /* check value */
04157          MCW_choose_cbs cb ;
04158          if( ii != 0 ) RETURN( False ) ;       /* this is bad */
04159          cb.reason = mcwCR_integer ;
04160          cb.fval   = *vvv ;
04161          GRA_finalize_global_baseline_CB(NULL,(XtPointer)grapher,&cb) ;
04162          RETURN( True ) ;
04163       }
04164 
04165       /*------ setmatrix [22 Sep 2000] -----*/
04166 
04167       case graDR_setmatrix:{
04168          int mm = (int) drive_data ;
04169          if( mm < 0 ) RETURN( False ) ;
04170          grapher->mat = MIN( grapher->mat_max , mm ) ;
04171          init_mat    ( grapher ) ;
04172          redraw_graph( grapher, PLOTCODE_AUTOSCALE ); /* 12 Oct 2000: autoscale */
04173          send_newinfo( grapher ) ;
04174          RETURN( True ) ;
04175       }
04176 
04177       /*------ setgrid [22 Sep 2000] -----*/
04178 
04179       case graDR_setgrid:{
04180          int mm = (int) drive_data ;
04181          if( mm < 2 ) RETURN( False ) ;
04182          grapher->grid_spacing = mm ;
04183          grapher->grid_fixed   = 1 ;  /* 02 Apr 2004 */
04184          redraw_graph(grapher,0) ;
04185          RETURN( True ) ;
04186       }
04187 
04188       /*------ mirroring (Jul 2000) -----*/
04189 
04190       case graDR_mirror:{
04191          int ii = (int) drive_data ;
04192 
04193          if( ii != grapher->mirror ){
04194            grapher->mirror = ii ;
04195            init_mat( grapher ) ; redraw_graph( grapher , 0 ) ;
04196          }
04197       }
04198       break ;
04199 
04200       /*------ fim disabling -----*/
04201 
04202       case graDR_fim_disable:{
04203          int ii ;
04204          XtUnmanageChild( grapher->fmenu->fim_cbut ) ;
04205          XtUnmanageChild( grapher->opt_xaxis_cbut ) ;
04206          for( ii=0 ; ii < NUM_COLOR_ITEMS ; ii++ ){
04207            if( gr_unfim[ii] ){
04208              if( grapher->opt_color_av[ii] != NULL )
04209                XtUnmanageChild( grapher->opt_color_av[ii]->wrowcol ) ;
04210              if( grapher->opt_thick_bbox[ii] != NULL )
04211                XtUnmanageChild( grapher->opt_thick_bbox[ii]->wtop  ) ;
04212              if( grapher->opt_points_bbox[ii] != NULL )
04213                XtUnmanageChild( grapher->opt_points_bbox[ii]->wtop ) ;
04214            }
04215          }
04216       }
04217       break ;
04218 
04219       /*------ button2 stuff -----*/
04220 
04221       case graDR_button2_enable:{
04222         grapher->button2_enabled = 1 ;
04223         GRA_timer_stop(grapher) ;   /* 04 Dec 2003 */
04224         RETURN( True ) ;
04225       }
04226 
04227       case graDR_button2_disable:{
04228         grapher->button2_enabled = 0 ;
04229         RETURN( True ) ;
04230       }
04231 
04232       /*------ set time index -----*/
04233 
04234       case graDR_setindex:{
04235          int new_index = (int) drive_data ;
04236 
04237          if( new_index < 0 || new_index >= grapher->status->num_series )
04238            RETURN( False ) ;
04239 
04240          if( new_index != grapher->time_index ){
04241            grapher->time_index = new_index ;
04242            if( grapher->textgraph )
04243              redraw_graph( grapher , 0 ) ;
04244            else
04245              GRA_redraw_overlay( grapher ) ;
04246          }
04247          RETURN( True ) ;
04248       }
04249 
04250       /*------ reset top of time series plotting ------*/
04251       /* (same as graDR_setpinnum and graDR_setpintop) */
04252 
04253       case graDR_newlength:{
04254          int newtop=(int)drive_data ;
04255 
04256          if( newtop < MIN_PIN ) newtop = 0 ;
04257          if( newtop > MAX_PIN ) newtop = MAX_PIN ;
04258 
04259          grapher->pin_top = newtop ;
04260          if( NPTS(grapher) < 2 ) grapher->pin_bot = 0 ;
04261 
04262 #ifdef USE_OPTMENUS
04263          GRA_fix_optmenus( grapher ) ;
04264 #endif
04265          redraw_graph( grapher, 0 ) ;
04266          RETURN( True ) ;
04267       }
04268 
04269       /*------ reset bottom of time series plotting [17 Mar 2004] -----*/
04270 
04271       case graDR_setpinbot:{
04272          int newbot=(int)drive_data ;
04273 
04274          if( newbot < 0               ) newbot = 0 ;
04275          if( newbot >= TTOP(grapher)  ) newbot = 0 ;
04276 
04277          grapher->pin_bot = newbot ;
04278 
04279 #ifdef USE_OPTMENUS
04280          GRA_fix_optmenus( grapher ) ;
04281 #endif
04282          redraw_graph( grapher, 0 ) ;
04283          RETURN( True ) ;
04284       }
04285 
04286       /*------ reset bot and top of time series plotting [19 Mar 2004] -----*/
04287 
04288       case graDR_setpins:{
04289          int ii=(int)drive_data , newbot,newtop ;
04290 
04291          if( ii <= 0 ){
04292            newbot = newtop = 0 ;
04293          } else {
04294            newbot = ii % 100000 ;
04295            newtop = ii / 100000 ;
04296            if( newtop < MIN_PIN ) newtop = 0 ;
04297          }
04298          if( newtop > 0 && newtop-newbot < 2 ) newbot = 0 ;
04299          if( newbot >= TTOP(grapher)         ) newbot = 0 ;
04300 
04301          grapher->pin_bot = newbot ;
04302          grapher->pin_top = newtop ;
04303 
04304 #ifdef USE_OPTMENUS
04305          GRA_fix_optmenus( grapher ) ;
04306 #endif
04307          redraw_graph( grapher, 0 ) ;
04308          RETURN( True ) ;
04309       }
04310 
04311       /*------ set ignore count -----*/
04312 
04313       case graDR_setignore:{
04314          int new_ignore = (int) drive_data ;
04315 
04316          if( new_ignore >= 0 && new_ignore < TTOP(grapher)-1 ){
04317            grapher->init_ignore = new_ignore ;
04318            redraw_graph( grapher , PLOTCODE_AUTOSCALE ) ;
04319            RETURN( True ) ;
04320          } else {
04321            RETURN( False ) ;
04322          }
04323       }
04324 
04325       /*------- set polort [27 May 1999] --------*/
04326 
04327       case graDR_polort:{
04328          int new_polort = (int) drive_data ;
04329 
04330          if( new_polort >= 0 ){
04331             grapher->polort = new_polort ;
04332 #ifdef USE_OPTMENUS
04333             GRA_fix_optmenus( grapher ) ;
04334 #endif
04335          }
04336          RETURN( True ) ;
04337       }
04338 
04339       /*----- set reference time series (currently limited to one) -----*/
04340 
04341       case graDR_addref_ts:{
04342          MRI_IMAGE *im = (MRI_IMAGE *) drive_data ;
04343 
04344          if( im == NULL ){                /* no input --> kill kill kill */
04345 STATUS("freeing reference timeseries") ;
04346             FREE_IMARR(grapher->ref_ts) ;
04347             grapher->ref_ts = NULL ;
04348          } else{
04349             if( grapher->ref_ts == NULL ) INIT_IMARR( grapher->ref_ts ) ;
04350 
04351             if( IMARR_COUNT(grapher->ref_ts) == 0 ){
04352 STATUS("adding reference timeseries") ;
04353                ADDTO_IMARR( grapher->ref_ts , im ) ;     /* create first one */
04354             } else {
04355 STATUS("replacing reference timeseries") ;
04356                IMARR_SUBIMAGE(grapher->ref_ts,0) = im ;  /* replace first one */
04357             }
04358          }
04359 
04360          redraw_graph( grapher , 0 ) ;
04361          RETURN( True ) ;
04362       }
04363 
04364       /*----- set ort time series (currently limited to one) -----*/
04365 
04366       case graDR_addort_ts:{
04367          MRI_IMAGE *im = (MRI_IMAGE *) drive_data ;
04368 
04369          if( im == NULL ){                /* no input --> kill kill kill */
04370 STATUS("freeing ort timeseries") ;
04371             FREE_IMARR(grapher->ort_ts) ;
04372             grapher->ort_ts = NULL ;
04373          } else{
04374             if( grapher->ort_ts == NULL ) INIT_IMARR( grapher->ort_ts ) ;
04375 
04376             if( IMARR_COUNT(grapher->ort_ts) == 0 ){
04377 STATUS("adding ort timeseries") ;
04378                ADDTO_IMARR( grapher->ort_ts , im ) ;     /* create first one */
04379             } else {
04380 STATUS("replacing ort timeseries") ;
04381                IMARR_SUBIMAGE(grapher->ort_ts,0) = im ;  /* replace first one */
04382             }
04383          }
04384 
04385          redraw_graph( grapher , 0 ) ;
04386          RETURN( True ) ;
04387       }
04388 
04389       /*------ set icon pixmap -----*/
04390 
04391       case graDR_icon:{
04392          int xret , yret ;
04393          unsigned int wret,hret,bret,dret ;
04394          Window rret ;
04395 
04396          XtVaSetValues( grapher->fdw_graph , XmNiconPixmap , (Pixmap) drive_data , NULL ) ;
04397          grapher->glogo_pixmap = (Pixmap) drive_data ;
04398 
04399          /* get geometry for later use */
04400 
04401          if( grapher->glogo_pixmap != XmUNSPECIFIED_PIXMAP ){
04402             (void) XGetGeometry( grapher->dc->display , grapher->glogo_pixmap ,
04403                                  &rret , &xret , &yret , &wret , &hret , &bret , &dret ) ;
04404 
04405             grapher->glogo_width  = wret ;
04406             grapher->glogo_height = hret ;
04407          } else {
04408             grapher->glogo_width  = 0 ;
04409             grapher->glogo_height = 0 ;
04410          }
04411          RETURN( True ) ;
04412       }
04413 
04414       /*------- title --------*/
04415 
04416       case graDR_title:{
04417          char * title = (char *) drive_data ;
04418 
04419          if( title == NULL || strlen(title) == 0 ) RETURN( False ) ;
04420 
04421          XtVaSetValues( grapher->fdw_graph , XmNtitle , title , NULL ) ;
04422          RETURN( True ) ;
04423       }
04424 
04425       /*------- death! -------*/
04426 
04427       case graDR_destroy:{
04428          end_fd_graph_CB( NULL , (XtPointer) grapher , NULL ) ;
04429          RETURN( True ) ;
04430       }
04431 
04432       /*------- unrealize! -------*/
04433 
04434       case graDR_unrealize:{
04435          GRA_timer_stop(grapher) ;   /* 04 Dec 2003 */
04436          if( GRA_REALZ(grapher) ) XtUnrealizeWidget( grapher->fdw_graph ) ;
04437          grapher->valid = 1 ;
04438 
04439          if( grapher->fd_pxWind != (Pixmap) 0 )
04440             XFreePixmap( grapher->dc->display , grapher->fd_pxWind ) ;
04441          RETURN( True ) ;
04442       }
04443 
04444       /*------- realize! -------*/
04445 
04446       case graDR_realize:{
04447          if( ! GRA_REALZ(grapher) ){
04448             int width , height ;
04449 
04450             grapher->valid = 2 ;
04451 
04452             XtRealizeWidget( grapher->fdw_graph ) ;
04453 
04454             WAIT_for_window(grapher->fdw_graph) ;
04455 
04456             /* 29 Sep 2000: next 2 lines of code are for the Form change */
04457 
04458             XtVaSetValues( grapher->option_rowcol ,
04459                              XmNleftAttachment   , XmATTACH_NONE ,
04460                              XmNtopAttachment    , XmATTACH_NONE ,
04461                              XmNrightAttachment  , XmATTACH_FORM ,
04462                              XmNbottomAttachment , XmATTACH_FORM ,
04463                            NULL ) ;
04464             XMapRaised( XtDisplay(grapher->option_rowcol) ,
04465                         XtWindow(grapher->option_rowcol)   ) ;
04466 
04467             NORMAL_cursorize( grapher->fdw_graph ) ;
04468 
04469             if( ISONE(grapher) )
04470               NORMAL_cursorize( grapher->draw_fd ) ;  /* 07 Dec 2001 */
04471             else
04472               POPUP_cursorize( grapher->draw_fd ) ;
04473 
04474             MCW_widget_geom( grapher->draw_fd , &width , &height , NULL,NULL ) ;
04475             GRA_new_pixmap( grapher , width , height , 0 ) ;
04476 #ifdef USE_OPTMENUS
04477             GRA_fix_optmenus( grapher ) ;
04478 #endif
04479             AFNI_sleep(1) ;  /* 08 Mar 2002: for good luck */
04480          }
04481          RETURN( True ) ;
04482       }
04483 
04484       /*------- new cursor for image -------*/
04485 
04486       case graDR_cursor:{
04487          int cur = (int) drive_data ;
04488 
04489          MCW_alter_widget_cursor( grapher->fdw_graph , cur , "yellow" , "blue" ) ;
04490          RETURN( True ) ;
04491       }
04492 
04493       /*------- new data sequence!!! -------*/
04494 
04495       case graDR_newdata:{
04496          int npold = grapher->status->num_series ;  /* 22 Sep 2000 */
04497 
04498          GRA_timer_stop(grapher) ;   /* 04 Dec 2003 */
04499 
04500          grapher->getaux = drive_data ;
04501 #if 0
04502          grapher->status = (MCW_grapher_status *)
04503                               grapher->getser(0,graCR_getstatus,drive_data) ;
04504 #else
04505          CALL_getser( grapher , 0,graCR_getstatus , MCW_grapher_status *,grapher->status ) ;
04506 #endif
04507          init_const( grapher ) ;
04508 
04509          /* mustn't allow bottom of plotting range to be beyond top of data! */
04510 
04511          if( grapher->pin_bot >= grapher->status->num_series-1 ) grapher->pin_bot = 0 ;
04512 
04513          if( npold < 2 || !grapher->grid_fixed ){ /* 22 Sep 2000 */
04514            auto_grid( grapher , NPTS(grapher) ) ;
04515          }
04516 
04517 #ifdef USE_OPTMENUS
04518          GRA_fix_optmenus( grapher ) ;
04519 #endif
04520 
04521         if( ISONE(grapher) )                        /* 07 Dec 2001 */
04522           NORMAL_cursorize( grapher->draw_fd ) ;
04523         else
04524           POPUP_cursorize( grapher->draw_fd ) ;
04525 
04526          RETURN( True ) ;
04527       }
04528 
04529       /*------- redraw -------*/
04530 
04531       case graDR_redraw:{
04532          int *xym = (int *) drive_data ;
04533 
04534 STATUS("graDR_redraw") ;
04535 
04536          if( xym != NULL ){
04537             if( xym[0] >= 0 ) grapher->xpoint = xym[0] ;
04538             if( xym[1] >= 0 ) grapher->ypoint = xym[1] ;
04539             if( xym[2] >= 0 ) grapher->zpoint = xym[2] ;
04540             if( xym[3] >  0 ) grapher->mat    = xym[3] ;
04541             init_mat(grapher) ;
04542          }
04543          redraw_graph( grapher , 0 ) ;
04544          RETURN( True ) ;
04545       }
04546 
04547    }  /* end of switch on drive_code */
04548 
04549    RETURN( False ) ;  /* should never be reached! */
04550 }

00943 {
00944    MCW_grapher * grapher = (MCW_grapher *) client_data ;
00945    int ii ;
00946 
00947 ENTRY("end_fd_graph_CB") ;
00948 
00949    if( ! GRA_VALID(grapher) ) EXRETURN ;
00950 
00951    GRA_timer_stop( grapher ) ;  /* 04 Dec 2003 */
00952 
00953    grapher->valid = 0 ;  /* can't do anything with this anymore */
00954 
00955    if( grapher->fd_pxWind != (Pixmap) 0 ){
00956 STATUS("freeing Pixmap") ;
00957      XFreePixmap( grapher->dc->display , grapher->fd_pxWind ) ;
00958    }
00959 
00960 #ifdef USE_OPTMENUS
00961 STATUS("destroying optmenus") ;
00962    FREE_AV(grapher->opt_mat_choose_av) ;
00963    FREE_AV(grapher->opt_slice_choose_av) ;
00964    FREE_AV(grapher->fmenu->fim_ignore_choose_av) ;
00965    FREE_AV(grapher->fmenu->fim_polort_choose_av) ;
00966 #endif
00967 
00968 STATUS("destroying arrowvals") ;
00969    FREE_AV( grapher->setshift_right_av)    ;
00970    FREE_AV( grapher->setshift_left_av)     ;
00971    FREE_AV( grapher->setshift_inc_av)      ;
00972    FREE_AV( grapher->transform0D_av )      ;  /* 22 Oct 1996 */
00973    FREE_AV( grapher->transform1D_av )      ;  /* 03 Nov 1996 */
00974    FREE_AV( grapher->opt_ggap_av )         ;  /* 28 Sep 1998: via Purify */
00975    FREE_AV( grapher->opt_gthick_av )       ;  /* 06 Oct 2004 */
00976 
00977    for( ii=0 ; ii < NUM_COLOR_ITEMS ; ii++ )  /* 16 Jun 1997 */
00978      FREE_AV( grapher->opt_color_av[ii] ) ;
00979 
00980 STATUS("destroying fmenu") ;
00981    myXtFree( grapher->fmenu->fim_editref_winaver_bbox );  /* 27 Jan 2004 */
00982    myXtFree( grapher->fmenu->fim_opt_bbox ) ;  /* Jan 1998 */
00983    myXtFree( grapher->fmenu->fimp_opt_bbox );  /* Jan 1998 */
00984    myXtFree( grapher->fmenu->fimp_user_bbox);  /* Feb 2000 */
00985    myXtFree( grapher->fmenu )               ;
00986    myXtFree( grapher->cen_line )            ;
00987 
00988 STATUS("destroying bboxes") ;
00989    myXtFree( grapher->opt_dplot_bbox ) ;         /* 08 Nov 1996 */
00990 
00991    for( ii=0 ; ii < NUM_COLOR_ITEMS ; ii++ ){
00992      myXtFree( grapher->opt_thick_bbox[ii] ) ;   /* 16 Jun 1997 */
00993      myXtFree( grapher->opt_points_bbox[ii] ) ;  /* 09 Jan 1998 */
00994    }
00995 
00996    myXtFree( grapher->opt_baseline_bbox ) ;      /* 07 Aug 2001 */
00997    myXtFree( grapher->opt_textgraph_bbox ) ;
00998 
00999 STATUS("freeing cen_tsim") ;
01000    mri_free( grapher->cen_tsim ) ;
01001    mri_free( grapher->xax_tsim ) ;  /* 09 Jan 1998 */
01002    mri_free( grapher->ave_tsim ) ;  /* 27 Jan 2004 */
01003 
01004 STATUS("freeing tuser") ;
01005    GRA_CLEAR_tuser( grapher ) ;  /* 22 Apr 1997 */
01006 
01007    /* 31 Mar 2004:
01008       On the Mac, destroying widgets after the timeseries
01009       chooser is opened causes death for unknown reasons.
01010       So in that case, just hide them.  What the ....?    */
01011 
01012 STATUS("destroying widgets") ;
01013 #ifdef DARWIN
01014    if( grapher->tschosen ) XtUnrealizeWidget( grapher->fdw_graph ) ;
01015    else                    XtDestroyWidget  ( grapher->fdw_graph ) ;
01016 #else
01017    XtUnrealizeWidget( grapher->fdw_graph ) ;
01018 #endif
01019 STATUS("widgets now destroyed") ;
01020 
01021    /** if AFNI has a notify callback, it will free the data **/
01022 
01023    if( grapher->status->send_CB != NULL ){
01024       GRA_cbs cbs ;
01025       cbs.reason = graCR_destroy ;
01026 STATUS("calling AFNI") ;
01027 #if 0
01028       grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
01029 #else
01030       CALL_sendback( grapher , cbs ) ;
01031 #endif
01032    } else {
01033 STATUS("freeing grapher") ;
01034       myXtFree( grapher ) ;    /* otherwise, we will free the data */
01035    }
01036 
01037    EXRETURN ;
01038 }

01045 {
01046 ENTRY("erase_fdw") ;
01047 
01048    if( grapher->dont_redraw ) EXRETURN ;  /* 27 Jan 2004 */
01049 
01050    DC_fg_color ( grapher->dc , BG_COLOR(grapher) ) ;
01051    DC_linewidth( grapher->dc , 0 ) ;
01052 
01053    XFillRectangle( grapher->dc->display ,
01054                    grapher->fd_pxWind , grapher->dc->myGC ,
01055                    0 , 0 , grapher->fWIDE , grapher->fHIGH ) ;
01056 
01057    if( show_grapher_pixmap &&
01058        grapher->glogo_pixmap != XmUNSPECIFIED_PIXMAP &&
01059        grapher->glogo_height > 0 && grapher->glogo_width > 0 ){
01060 
01061       XCopyArea( grapher->dc->display ,
01062                  grapher->glogo_pixmap , grapher->fd_pxWind , grapher->dc->myGC ,
01063                  0,0 , grapher->glogo_width,grapher->glogo_height ,
01064                  0,grapher->fHIGH - grapher->glogo_height + 1 ) ;
01065    }
01066 
01067    EXRETURN ;
01068 }

01516 {
01517    XDrawLine( grapher->dc->display , grapher->fd_pxWind ,
01518               grapher->dc->myGC , x1,grapher->fHIGH-y1,x2,grapher->fHIGH-y2 ) ;
01519    return ;
01520 }

01094 {
01095 ENTRY("fd_px_store") ;
01096 
01097    if( ! MCW_widget_visible(grapher->draw_fd) ) EXRETURN ;  /* 03 Jan 1999 */
01098 
01099    XtVaSetValues( grapher->draw_fd ,
01100                      XmNbackgroundPixmap , grapher->fd_pxWind ,
01101                   NULL ) ;
01102 
01103    XClearWindow( grapher->dc->display , XtWindow(grapher->draw_fd) ) ;
01104    XFlush( grapher->dc->display ) ;
01105    EXRETURN ;
01106 }

01496 {
01497    XDrawString( grapher->dc->display, grapher->fd_pxWind,
01498                 grapher->dc->myGC , x , grapher->fHIGH-y ,
01499                 str , strlen(str) ) ;
01500    return ;
01501 }

05591 {
05592    MCW_grapher *grapher = (MCW_grapher *) client_data ;
05593    int bbb ;
05594 
05595 ENTRY("GRA_baseline_CB") ;
05596 
05597    if( ! GRA_VALID(grapher) ) EXRETURN ;
05598 
05599    bbb = MCW_val_bbox( grapher->opt_baseline_bbox ) ;
05600    if( bbb != grapher->common_base ){
05601      grapher->common_base = bbb ;
05602      redraw_graph( grapher , 0 ) ;
05603    }
05604    EXRETURN ;
05605 }

03929 {
03930 ENTRY("GRA_bkthr_choose_CB") ;
03931    SET_FIM_bkthr( cbs->fval ) ;
03932    EXRETURN ;
03933 }

05770 {
05771    MCW_grapher *grapher = (MCW_grapher *) cd ;
05772    int ii , jj ;
05773 
05774 ENTRY("GRA_color_CB") ;
05775 
05776    if( ! GRA_VALID(grapher) ) EXRETURN ;
05777 
05778    for( ii=0 ; ii < NUM_COLOR_ITEMS ; ii++ )
05779      if( av == grapher->opt_color_av[ii] ) break ;
05780 
05781    if( ii < NUM_COLOR_ITEMS ){
05782      jj = grapher->color_index[ii] ;
05783      grapher->color_index[ii] = av->ival ;
05784      if( jj != grapher->color_index[ii] ) redraw_graph( grapher , 0 ) ;
05785    }
05786    EXRETURN ;
05787 }

05046 {
05047    MRI_IMAGE * tsim , * newim , * tim ;
05048    float * tsar , * nar , * tar ;
05049    int ii,ivec , nx , newny , nleft,nright ;
05050    float shinc ;
05051    GRA_cbs gbs ;
05052 
05053 ENTRY("GRA_doshift") ;
05054 
05055    if( !GRA_VALID(grapher) ) EXRETURN ;
05056 
05057    if( grapher->status->send_CB == NULL                       ||
05058        grapher->setshift_inc <= 0.0                           ||
05059        grapher->setshift_left + grapher->setshift_right <= 0  ||
05060        grapher->ref_ts == NULL                                ||
05061        IMARR_COUNT(grapher->ref_ts) == 0                        ){
05062 
05063       XBell( grapher->dc->display , 100 ) ; EXRETURN ;
05064    }
05065 
05066    tsim = IMARR_SUBIMAGE(grapher->ref_ts,0) ; /* current ref */
05067    tsar = MRI_FLOAT_PTR(tsim) ;
05068    nx   = tsim->nx ;
05069 
05070    shinc  = grapher->setshift_inc ;
05071    nleft  = grapher->setshift_left ;
05072    nright = grapher->setshift_right ;
05073    newny  = 1 + nleft + nright ;
05074    newim  = mri_new( nx , newny , MRI_float ) ;
05075    nar    = MRI_FLOAT_PTR(newim) ;
05076 
05077    for( ii=0 ; ii < nx ; ii++ )
05078       nar[ii] = (ii < grapher->init_ignore) ? WAY_BIG : tsar[ii] ;
05079 
05080    for( ivec=1 ; ivec <= nleft ; ivec++ ){
05081       tim = mri_shift_1D( newim , -ivec * shinc ) ;
05082       tar = MRI_FLOAT_PTR(tim) ;
05083       for( ii=0 ; ii < nx ; ii++ ) nar[ii+ivec*nx] = tar[ii] ;
05084       mri_free(tim) ;
05085    }
05086 
05087    for( ivec=1 ; ivec <= nright ; ivec++ ){
05088       tim = mri_shift_1D( newim , ivec * shinc ) ;
05089       tar = MRI_FLOAT_PTR(tim) ;
05090       for( ii=0 ; ii < nx ; ii++ ) nar[ii+(ivec+nleft)*nx] = tar[ii] ;
05091       mri_free(tim) ;
05092    }
05093 
05094    { GRA_cbs cbs; cbs.reason=graCR_winaver; CALL_sendback(grapher,cbs); }
05095    MCW_set_bbox( grapher->fmenu->fim_editref_winaver_bbox , 0 ) ;
05096    gbs.reason   = graCR_refequals ;
05097    gbs.userdata = (XtPointer) newim ;
05098 #if 0
05099    grapher->status->send_CB( grapher , grapher->getaux , &gbs ) ;
05100 #else
05101    CALL_sendback( grapher , gbs ) ;
05102 #endif
05103    mri_free( newim ) ;
05104    EXRETURN ;
05105 }

05690 {
05691    MCW_grapher *grapher = (MCW_grapher *) client_data ;
05692 
05693 ENTRY("GRA_dplot_change_CB") ;
05694 
05695    if( ! GRA_REALZ(grapher) ) EXRETURN ;
05696    redraw_graph( grapher , 0 ) ;
05697    EXRETURN ;
05698 }

01184 {
01185    int xb,yb ;
01186    unsigned int ww ;
01187 
01188    if( rad < 0 ) rad = 0 ;
01189    xb = xc-rad ; yb = yc-rad ; ww = 2*rad ;
01190    XDrawArc( grapher->dc->display , XtWindow(grapher->draw_fd) ,
01191              grapher->dc->myGC , xb,yb , ww,ww , 0,360*64 ) ;
01192 }

02712 {
02713    MCW_grapher * grapher = (MCW_grapher *) client_data ;
02714 
02715 ENTRY("GRA_drawing_EV") ;
02716 
02717    if( ! GRA_REALZ(grapher) ){
02718 if(PRINT_TRACING){
02719 char str[256] ;
02720 sprintf(str,"unrealized grapher! Event type = %d",(int)ev->type) ;
02721 STATUS(str) ; }
02722       EXRETURN ;
02723    }
02724 
02725    if( grapher->valid == 666 ){  /* 06 Jan 1999 */
02726 if(PRINT_TRACING){
02727 char str[256] ;
02728 sprintf(str,"dying grapher! Event type = %d",(int)ev->type) ;
02729 STATUS(str) ; }
02730       EXRETURN ;
02731    }
02732 
02733    switch( ev->type ){
02734 
02735       /*----- redraw -----*/
02736 
02737       case Expose:{
02738          XExposeEvent * event = (XExposeEvent *) ev ;
02739 
02740 if(PRINT_TRACING){
02741 char str[256] ;
02742 sprintf(str,"Expose event with count = %d",event->count) ;
02743 STATUS(str) ; }
02744 
02745          /**
02746              With the first expose, create the new pixmap.
02747              For subsequent ones, just redraw the non-pixmap (overlay) stuff.
02748 
02749              06 Jan 1999: check event count
02750          **/
02751 
02752          XSync( XtDisplay(w) , False ) ;  /* 05 Feb 1999 */
02753 
02754          if( event->count == 0 ){
02755             if( grapher->fd_pxWind == (Pixmap) 0 ){
02756                int width , height ;
02757                MCW_widget_geom( grapher->draw_fd , &width , &height , NULL,NULL ) ;
02758                GRA_new_pixmap( grapher , width , height , 1 ) ;
02759             } else {
02760                GRA_redraw_overlay( grapher ) ;
02761             }
02762          }
02763       }
02764       break ;
02765 
02766       /*----- take key press -----*/
02767 
02768       case KeyPress:{
02769          XKeyEvent * event = (XKeyEvent *) ev ;
02770          char           buf[32] ;
02771          KeySym         ks=0 ;
02772          int            nbuf ;
02773 
02774 STATUS("KeyPress event") ;
02775 
02776          GRA_timer_stop( grapher ) ;  /* 04 Dec 2003 */
02777 
02778          if( grapher->fd_pxWind != (Pixmap) 0 ){
02779             buf[0] = '\0' ;
02780             nbuf = XLookupString( event , buf , 32 , &ks , NULL ) ;
02781             if( nbuf == 0 ){   /* 24 Jan 2003: substitution for special keys */
02782               switch(ks){
02783                 case XK_KP_Left:
02784                 case XK_Left:      buf[0] = '<' ; break ;
02785                 case XK_KP_Right:
02786                 case XK_Right:     buf[0] = '>' ; break ;
02787                 case XK_KP_Page_Up:
02788                 case XK_Page_Up:   buf[0] = 'Z' ; break ;
02789                 case XK_KP_Page_Down:
02790                 case XK_Page_Down: buf[0] = 'z' ; break ;
02791               }
02792             }
02793             if( buf[0] != '\0' ) GRA_handle_keypress( grapher , buf , ev ) ;
02794             else if(PRINT_TRACING){
02795                char str[256] ;
02796                sprintf(str,"*** KeyPress was empty!?  nbuf=%d",nbuf) ;
02797                STATUS(str) ;
02798             }
02799          }
02800       }
02801       break ;
02802 
02803       /*----- take button press -----*/
02804 
02805       case ButtonPress:{
02806          XButtonEvent * event = (XButtonEvent *) ev ;
02807          int bx,by , width,height , but ;
02808          int i, j, gx , gy , mat , xloc,yloc ;
02809          unsigned int but_state ;
02810          int xd,yd,zd ;  /* 19 Mar 2004: for mangling to AFNI indexes */
02811 
02812 STATUS("button press") ;
02813 
02814          bx  = event->x ;
02815          by  = event->y ;
02816          but = event->button ; but_state = event->state ;
02817          MCW_discard_events( w , ButtonPressMask ) ;
02818 
02819          /* Button 1 in pixmap logo = toggle on or off */
02820 
02821          if( but == Button1                                &&
02822              grapher->glogo_pixmap != XmUNSPECIFIED_PIXMAP &&
02823              bx < grapher->glogo_width                     &&
02824              grapher->fHIGH - by < grapher->glogo_height     ){
02825 
02826             show_grapher_pixmap = ! show_grapher_pixmap ;
02827 
02828             if( XtIsManaged(grapher->option_rowcol) )     /* 04 Nov 1996 */
02829               XtUnmanageChild(grapher->option_rowcol) ;
02830             else
02831               XtManageChild(grapher->option_rowcol) ;
02832 
02833             redraw_graph( grapher , 0 )  ;
02834             break ; /* break out of ButtonPress case */
02835          }
02836 
02837          /* compute which dataset pixel (xloc,yloc) the button press was in */
02838 
02839          /* X11 box for graph (i,j):
02840             x = xorigin[i][j]          .. xorigin[i][j]+gx    (L..R)
02841             y = fHIGH-yorigin[i][j]-gy .. fHIGH-yorigin[i][j] (T..B) */
02842 
02843          gx = grapher->gx ; gy = grapher->gy ; mat = grapher->mat ;
02844 
02845          for( i=0 ; i < mat ; i++ )
02846            if( bx > grapher->xorigin[i][0]      &&
02847                bx < grapher->xorigin[i][0] + gx   ) break ;  /* find in x */
02848 
02849          if( i == mat ) break ; /* break out of ButtonPress case */
02850 
02851          xloc = grapher->xpoint + i - grapher->xc ;
02852 
02853          for( j=0 ; j < mat ; j++ )                           /* find in y */
02854            if( by > grapher->fHIGH - grapher->yorigin[0][j] - gy &&
02855                by < grapher->fHIGH - grapher->yorigin[0][j]        ) break ;
02856 
02857          if( j == mat ) break ; /* break out of ButtonPress case */
02858 
02859          yloc = grapher->ypoint - j + grapher->yc ;
02860 
02861          /* adjust for possible wraparound */
02862 
02863          if (xloc < 0)                    xloc += grapher->status->nx ;
02864          if (xloc >= grapher->status->nx) xloc -= grapher->status->nx ;
02865          if (yloc < 0)                    yloc += grapher->status->ny ;
02866          if (yloc >= grapher->status->ny) yloc -= grapher->status->ny ;
02867 
02868          /* Feb 1998: button 2 --> send message back to AFNI, maybe */
02869          /* 03 Oct 2002: Shift+Button1 has the same effect */
02870 
02871          if( but == Button2 ||
02872              ( but == Button1 && (event->state & ShiftMask) &&
02873                                 !(event->state & ControlMask) ) ){
02874 
02875             if( grapher->button2_enabled && (bx > GL_DLX) ){
02876                GRA_cbs cbs ;
02877                cbs.reason = graCR_button2_points ;
02878                cbs.xcen   = xloc ;
02879                cbs.ycen   = yloc ;
02880                cbs.zcen   = grapher->zpoint ;
02881 #if 0
02882                grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
02883 #else
02884                CALL_sendback( grapher , cbs ) ;
02885 #endif
02886             } else {
02887                XBell(XtDisplay(w),100) ;
02888             }
02889          }
02890 
02891          /* button 1 --> move to new square as center of matrix,
02892                          if it is actually a new center, that is,
02893                          and if graphing is enabled, and if not off left edge */
02894 
02895          if( grapher->fd_pxWind != (Pixmap) 0 &&
02896              but == Button1                   && (bx > GL_DLX) &&
02897              ( (xloc != grapher->xpoint) || (yloc != grapher->ypoint) ) ){
02898 
02899                grapher->xpoint = xloc ;
02900                grapher->ypoint = yloc ;
02901                redraw_graph( grapher , 0 ) ;
02902                send_newinfo( grapher ) ;
02903          }
02904 
02905          /* 22 July 1996:
02906             button 1 in central graph of matrix causes jump to time_index */
02907 
02908          else if( grapher->fd_pxWind != (Pixmap)0 &&
02909                   NPTS(grapher) > 1               && !grapher->textgraph     &&
02910                   (but==Button1)                  && (bx > GL_DLX)           &&
02911                   (xloc == grapher->xpoint)       && yloc == grapher->ypoint &&
02912                   grapher->cen_line != NULL       && grapher->nncen > 1        ){
02913 
02914            float dist , dmin=999999.9 ;
02915            int imin = 0 ;
02916 
02917            /*-- 09 Jan 1998: find closest pixel in central graph --*/
02918 
02919            for( i=0 ; i < grapher->nncen ; i++ ){
02920              dist =  abs( bx - grapher->cen_line[i].x )   /* L1 distance */
02921                    + abs( by - grapher->cen_line[i].y ) ;
02922              if( dist < dmin ){ dmin = dist; imin = i; if(dmin == 0) break; }
02923            }
02924            i = imin + NBOT(grapher) ;
02925 
02926            if( i >= 0 && i < TTOP(grapher) ){
02927              if( grapher->status->send_CB != NULL ){
02928                GRA_cbs cbs ;
02929 
02930                cbs.reason = graCR_setindex ;
02931                cbs.key    = i ;
02932                cbs.event  = ev ;
02933 #if 0
02934                grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
02935 #else
02936                CALL_sendback( grapher , cbs ) ;
02937 #endif
02938              } else {
02939                (void) drive_MCW_grapher( grapher,graDR_setindex,(XtPointer)i );
02940              }
02941            }
02942          }
02943 
02944          /* Button 3 --> popup statistics of this graph */
02945 
02946          if( but == Button3 && !ISONE(grapher) && !grapher->textgraph ){
02947             int ix , iy ;
02948 
02949             ix = xloc - grapher->xpoint + grapher->xc ;
02950                  if( ix <  0            ) ix += grapher->status->nx ;
02951             else if( ix >= grapher->mat ) ix -= grapher->status->nx ;
02952 
02953             iy = grapher->ypoint - yloc + grapher->yc ;
02954                  if( iy <  0            ) iy += grapher->status->ny ;
02955             else if( iy >= grapher->mat ) iy -= grapher->status->ny ;
02956 
02957             if( ix >= 0 && ix < grapher->mat && iy >= 0 && iy < grapher->mat ){
02958                XmString xstr ;
02959                char bmin[16],bmax[16],bmean[16],bstd[16] ;
02960                char bmed[16] , bmad[16] ; /* 08 Mar 2001 */
02961                char *qstr , *eee ;        /* 07 Mar 2002 */
02962                int nlin , nltop=40 ;      /* 07 Mar 2002 */
02963 
02964                AV_fval_to_char( grapher->tbot[ix][iy]  , bmin ) ;
02965                AV_fval_to_char( grapher->ttop[ix][iy]  , bmax ) ;
02966                AV_fval_to_char( grapher->tmean[ix][iy] , bmean) ;
02967                AV_fval_to_char( grapher->tstd[ix][iy]  , bstd ) ;
02968 
02969                AV_fval_to_char( grapher->tmed[ix][iy]  , bmed ) ; /* 08 Mar 2001 */
02970                AV_fval_to_char( grapher->tmad[ix][iy]  , bmad ) ;
02971 
02972                if( grapher->tuser[ix][iy] == NULL )
02973                  qstr = AFMALL(char, 912) ;
02974                else
02975                  qstr = AFMALL(char, 912+strlen(grapher->tuser[ix][iy])) ;
02976 
02977                /* 19 Mar 2004: mangle FD_brick indexes to AFNI indexes */
02978 
02979                xd = xloc; yd = yloc; zd = grapher->zpoint ;
02980 #ifndef DONT_MANGLE_XYZ
02981                { THD_ivec3 id ;
02982                  id = THD_fdind_to_3dind( grapher->getaux , TEMP_IVEC3(xd,yd,zd) ) ;
02983                  xd = id.ijk[0] ; yd = id.ijk[1] ; zd = id.ijk[2] ; }
02984 #endif
02985                sprintf( qstr, "Data Statistics\n"
02986                               "---------------\n"
02987                               "Indexes = %d:%-d\n" /* 19 Mar 2004 */
02988                               "x voxel = %d\n"
02989                               "y voxel = %d\n"
02990                               "z voxel = %d\n"
02991                               "Min     =%s\n"
02992                               "Max     =%s\n"
02993                               "Mean    =%s\n"
02994                               "Sigma   =%s\n"
02995                               "Median  =%s\n"     /* 08 Mar 2001 */
02996                               "MAD     =%s" ,
02997                         grapher->sbot[ix][iy], grapher->stop[ix][iy], /* 19 Mar 2004 */
02998                         xd , yd , zd ,
02999                         bmin,bmax,bmean,bstd,bmed,bmad ) ;
03000 
03001                 /** 22 Apr 1997: incorporate user string for this voxel **/
03002 
03003                 if( grapher->tuser[ix][iy] != NULL ){
03004                   strcat( qstr , "\n------------------\n" ) ;
03005                   strcat( qstr , grapher->tuser[ix][iy] ) ;
03006                 }
03007 
03008                 /* 07 Mar 2002: if string is too long, popup textwin,
03009                                 otherwise just open a popup window    */
03010 
03011                 eee = getenv( "AFNI_GRAPH_TEXTLIMIT" ) ;
03012                 if( eee != NULL ){
03013                   nlin = strtol( eee , NULL , 10 ) ;
03014                   if( nlin > 0 ) nltop = nlin ;
03015                 }
03016 
03017                 for( nlin=1,eee=qstr ; *eee != '\0' ; eee++ )
03018                   if( *eee == '\n' ) nlin++ ;
03019 
03020                 if( nlin < nltop ){
03021                   xstr = XmStringCreateLtoR( qstr, XmFONTLIST_DEFAULT_TAG ) ;
03022                   XtVaSetValues( grapher->but3_label,XmNlabelString,xstr,NULL );
03023                   XmStringFree( xstr ) ;
03024                   XmMenuPosition( grapher->but3_menu , event ) ; /* where */
03025                   XtManageChild ( grapher->but3_menu ) ;         /* popup */
03026                 } else {
03027                   (void) new_MCW_textwin(grapher->fdw_graph,qstr,TEXT_READONLY);
03028                 }
03029                 free(qstr) ;
03030 
03031             } else {
03032               redraw_graph(grapher,0) ;  /* 11 Nov 1996 */
03033             }
03034          }
03035       }
03036       break ;
03037 
03038       /*----- window changed size -----*/
03039 
03040       case ConfigureNotify:{
03041          XConfigureEvent * event = (XConfigureEvent *) ev ;
03042          int new_width , new_height ;
03043 
03044 STATUS("ConfigureNotify event") ;
03045 
03046          XSync( XtDisplay(w) , False ) ;
03047 
03048          new_width  = event->width ;
03049          new_height = event->height ;
03050 
03051          if( new_width != grapher->fWIDE || new_height != grapher->fHIGH ){
03052            GRA_new_pixmap( grapher , new_width , new_height , 1 ) ;
03053          }
03054       }
03055       break ;
03056 
03057       /*----- ignore all other events -----*/
03058 
03059       default:
03060 #ifdef AFNI_DEBUG
03061 {char str[256]; sprintf(str,"Event code = %d\n",(int)ev->type); STATUS(str);}
03062 #endif
03063       break ;
03064 
03065    } /* end of switch ev->type */
03066 
03067    EXRETURN ;
03068 }

05872 {
05873    XImage *xim ;
05874    XGCValues gcv ;
05875    MRI_IMAGE *tim ;
05876    int ii ;
05877 
05878 ENTRY("GRA_file_pixmap") ;
05879 
05880    if( ! GRA_REALZ(grapher) ) EXRETURN ;
05881    if( grapher->fd_pxWind == (Pixmap) 0 ) EXRETURN ;
05882 
05883    ii = XGetGCValues( grapher->dc->display ,
05884                       grapher->dc->myGC , GCPlaneMask , &gcv ) ;
05885    if( ii == 0 ) EXRETURN ;
05886 
05887    xim = XGetImage( grapher->dc->display , grapher->fd_pxWind ,
05888                     0 , 0 , grapher->fWIDE , grapher->fHIGH ,
05889                     gcv.plane_mask , ZPixmap ) ;
05890    if( xim == NULL ) EXRETURN ;
05891 
05892    tim = XImage_to_mri( grapher->dc , xim , 0 ) ;
05893    if( tim == NULL ){ MCW_kill_XImage( xim ) ; EXRETURN ; }
05894 
05895    mri_write_pnm( fname , tim ) ;
05896    INFO_message("Writing grapher image to file %s\n",fname) ;
05897    mri_free( tim ) ;
05898    MCW_kill_XImage( xim ) ;  /* 10 Mar 1999 */
05899    EXRETURN ;
05900 }

04557 {
04558    FIM_menu * fm = (FIM_menu *) client_data ;
04559    MCW_grapher * grapher = (MCW_grapher *) fm->parent ;
04560    GRA_cbs cbs ;
04561 
04562 ENTRY("GRA_fim_CB") ;
04563 
04564    if( ! GRA_VALID(grapher) || grapher->status->send_CB == NULL ) EXRETURN ;
04565 
04566    EXRONE(grapher) ;  /* 22 Sep 2000 */
04567 
04568    /*--- carry out action, depending on which widget called me ---*/
04569 
04570    /*** Pick reference ***/
04571 
04572    if( w == grapher->fmenu->fim_pickref_pb ){
04573       cbs.reason = graCR_pickref ;
04574 #if 0
04575       grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
04576 #else
04577       CALL_sendback( grapher , cbs ) ;
04578 #endif
04579       grapher->tschosen = 1 ;  /* 31 Mar 2004 */
04580    }
04581 
04582    /*** Pick ort ***/
04583 
04584    else if( w == grapher->fmenu->fim_pickort_pb ){
04585       cbs.reason = graCR_pickort ;
04586 #if 0
04587       grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
04588 #else
04589       CALL_sendback( grapher , cbs ) ;
04590 #endif
04591       grapher->tschosen = 1 ;  /* 31 Mar 2004 */
04592    }
04593 
04594    /*** Clear FIM ***/
04595 
04596    else if( w == grapher->fmenu->fim_editref_clear_pb ){
04597       cbs.reason = graCR_clearfim ;
04598 #if 0
04599       grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
04600 #else
04601       CALL_sendback( grapher , cbs ) ;
04602 #endif
04603    }
04604 
04605    /*** Clear Ort ***/
04606 
04607    else if( w == grapher->fmenu->fim_editort_clear_pb ){
04608       cbs.reason = graCR_clearort ;
04609 #if 0
04610       grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
04611 #else
04612       CALL_sendback( grapher , cbs ) ;
04613 #endif
04614    }
04615 
04616    /*** set ref to central time series ***/
04617 
04618    else if( w == grapher->fmenu->fim_editref_equals_pb ||
04619             w == grapher->fmenu->fim_editref_add_pb      ){
04620       int ll ;
04621       MRI_IMAGE * tsim ;
04622 
04623       ll = grapher->xpoint +
04624            grapher->ypoint * grapher->status->nx +
04625            grapher->zpoint * grapher->status->nx * grapher->status->ny ;
04626 
04627 #if 0
04628       tsim  = (MRI_IMAGE *) grapher->getser( ll , graCR_getseries ,
04629                                                   grapher->getaux ) ;
04630 #else
04631       CALL_getser( grapher , ll,graCR_getseries , MRI_IMAGE *,tsim ) ;
04632 #endif
04633 
04634       if( tsim != NULL ){
04635          { GRA_cbs cbs; cbs.reason=graCR_winaver; CALL_sendback(grapher,cbs); }
04636          MCW_set_bbox( grapher->fmenu->fim_editref_winaver_bbox , 0 ) ;
04637          cbs.reason   = (w == grapher->fmenu->fim_editref_equals_pb)
04638                         ? graCR_refequals : graCR_refadd ;
04639          cbs.userdata = (XtPointer) tsim ;
04640 #if 0
04641          grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
04642 #else
04643          CALL_sendback( grapher , cbs ) ;
04644 #endif
04645          mri_free( tsim ) ;
04646       }
04647    }
04648 
04649    /*** read or write or smooth ***/
04650 
04651    else if( w == grapher->fmenu->fim_editref_read_pb ){
04652       MCW_choose_string( grapher->option_rowcol ,
04653                          "Ideal Input Filename:" , NULL ,
04654                          GRA_refread_choose_CB , (XtPointer) grapher ) ;
04655    }
04656 
04657    else if( w == grapher->fmenu->fim_editref_write_pb ){
04658       if( grapher->ref_ts != NULL && IMARR_COUNT(grapher->ref_ts) > 0 ){
04659          MCW_choose_string( grapher->option_rowcol ,
04660                             "Ideal Output Filename:" , NULL ,
04661                             GRA_refwrite_choose_CB , (XtPointer) grapher ) ;
04662       } else {
04663          XBell( grapher->dc->display , 100 ) ;
04664       }
04665    }
04666 
04667    else if( w == grapher->fmenu->fim_editref_store_pb ){
04668       if( grapher->ref_ts != NULL && IMARR_COUNT(grapher->ref_ts) > 0 ){
04669          MCW_choose_string( grapher->option_rowcol ,
04670                             "Label to Store Ideal:" , NULL ,
04671                             GRA_refstore_choose_CB , (XtPointer) grapher ) ;
04672       } else {
04673          XBell( grapher->dc->display , 100 ) ;
04674       }
04675    }
04676 
04677    else if( w == grapher->fmenu->fim_editref_smooth_pb ){
04678       cbs.reason = graCR_refsmooth ;
04679       if( grapher->ref_ts != NULL && IMARR_COUNT(grapher->ref_ts) > 0 ){
04680          { GRA_cbs cbs; cbs.reason=graCR_winaver; CALL_sendback(grapher,cbs); }
04681          MCW_set_bbox( grapher->fmenu->fim_editref_winaver_bbox , 0 ) ;
04682 #if 0
04683          grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
04684 #else
04685          CALL_sendback( grapher , cbs ) ;
04686 #endif
04687       } else {
04688          XBell( grapher->dc->display , 100 ) ;
04689       }
04690    }
04691 
04692    /*** Set shifts ***/
04693 
04694    else if( w == grapher->fmenu->fim_editref_setshift_pb ){
04695       GRA_setshift_startup( grapher ) ;
04696    }
04697 
04698    /*** Execute FIM ***/
04699 
04700    else if( w == grapher->fmenu->fim_execute_pb ){
04701       int val = MCW_val_bbox(grapher->fmenu->fim_opt_bbox) ;
04702       cbs.reason = graCR_dofim ;
04703       switch(val){
04704          default:  cbs.key = FIM_ALPHA_MASK | FIM_CORR_MASK ; break ;
04705          case 2:   cbs.key = FIM_PERC_MASK  | FIM_CORR_MASK ; break ;
04706          case 4:   cbs.key = FIM_PAVE_MASK  | FIM_CORR_MASK ; break ;
04707          case 3:   cbs.key = FIM_PTOP_MASK  | FIM_CORR_MASK ; break ;
04708       }
04709       cbs.mat = 0 ; /* Feb 2000 */
04710       GRA_timer_stop(grapher) ;   /* 04 Dec 2003 */
04711 #if 0
04712       grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
04713 #else
04714       CALL_sendback( grapher , cbs ) ;
04715 #endif
04716    }
04717 
04718    else if( w == grapher->fmenu->fim_execfimp_pb ){
04719       cbs.reason = graCR_dofim ;
04720       cbs.key    = MCW_val_bbox(grapher->fmenu->fimp_opt_bbox) ;
04721       cbs.mat    = MCW_val_bbox(grapher->fmenu->fimp_user_bbox) ; /* Feb 2000 */
04722       GRA_timer_stop(grapher) ;   /* 04 Dec 2003 */
04723       if( cbs.key || cbs.mat )
04724 #if 0
04725          grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
04726 #else
04727          CALL_sendback( grapher , cbs ) ;
04728 #endif
04729       else
04730          XBell( grapher->dc->display , 100 ) ;
04731    }
04732 
04733    /*** 04 Jan 2000: modify the FIM+ button settings ***/
04734 
04735    else if( w == grapher->fmenu->fimp_setdefault_pb ){
04736      char * ff = my_getenv( "AFNI_FIM_MASK" ) ; int mm=0 ;
04737      if( ff != NULL ) mm = strtol(ff,NULL,10) ;
04738      if( mm <= 0 ) mm = FIM_DEFAULT_MASK ;
04739      MCW_set_bbox( grapher->fmenu->fimp_opt_bbox , mm ) ;
04740    }
04741 
04742    else if( w == grapher->fmenu->fimp_setall_pb ){
04743       int mm = (2 << FIM_NUM_OPTS) - 1 ;
04744       MCW_set_bbox( grapher->fmenu->fimp_opt_bbox , mm ) ;
04745    }
04746 
04747    else if( w == grapher->fmenu->fimp_unsetall_pb ){
04748       MCW_set_bbox( grapher->fmenu->fimp_opt_bbox , 0 ) ;
04749    }
04750 
04751    /*** FIM plotting buttons ***/
04752 
04753    else if( w == grapher->fmenu->fim_plot_firstref_pb ){
04754       if( grapher->ref_ts_plotall != 0 ){
04755          grapher->ref_ts_plotall = 0 ;
04756          redraw_graph( grapher , 0 ) ;
04757       }
04758    }
04759 
04760    else if( w == grapher->fmenu->fim_plot_allrefs_pb ){
04761       if( grapher->ref_ts_plotall == 0 ){
04762          grapher->ref_ts_plotall = 1 ;
04763          redraw_graph( grapher , 0 ) ;
04764       }
04765    }
04766 
04767    /*** Ignore stuff ***/
04768 
04769    else if( w == grapher->fmenu->fim_ignore_down_pb && grapher->status->send_CB != NULL ){
04770       GRA_cbs cbs ;
04771 
04772       cbs.reason = graCR_setignore ;
04773       cbs.key    = grapher->init_ignore - 1 ;
04774 #if 0
04775       grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
04776 #else
04777       CALL_sendback( grapher , cbs ) ;
04778 #endif
04779    }
04780 
04781    else if( w == grapher->fmenu->fim_ignore_up_pb && grapher->status->send_CB != NULL ){
04782       GRA_cbs cbs ;
04783 
04784       cbs.reason = graCR_setignore ;
04785       cbs.key    = grapher->init_ignore + 1 ;
04786 #if 0
04787       grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
04788 #else
04789       CALL_sendback( grapher , cbs ) ;
04790 #endif
04791    }
04792 
04793    else if( w == grapher->fmenu->fim_ignore_choose_pb && grapher->status->send_CB != NULL ){
04794 #ifdef USE_OPTMENUS
04795       GRA_ignore_choose_CB( grapher->fmenu->fim_ignore_choose_av , grapher ) ;
04796 #else
04797       MCW_choose_integer( grapher->option_rowcol , "Initial Ignore" ,
04798                           0 , grapher->status->num_series-1 , grapher->init_ignore ,
04799                           GRA_ignore_choose_CB , (XtPointer) grapher ) ;
04800 #endif
04801    }
04802 
04803    /* 27 May 1999: set polort */
04804 
04805    else if( w == grapher->fmenu->fim_polort_choose_pb && grapher->status->send_CB != NULL ){
04806 #ifdef USE_OPTMENUS
04807       GRA_polort_choose_CB( grapher->fmenu->fim_polort_choose_av , grapher ) ;
04808 #else
04809       MCW_choose_integer( grapher->option_rowcol , "Polort Order" ,
04810                           0 , MAX_POLORT , grapher->polort ,
04811                           GRA_polort_choose_CB , (XtPointer) grapher ) ;
04812 #endif
04813    }
04814 
04815    /* 02 Jun 1999: set FIM bkg threshold */
04816 
04817    else if( w == grapher->fmenu->fim_bkthr_choose_pb ){
04818       MCW_choose_integer( grapher->option_rowcol , "Bkg Thresh %" ,
04819                           0 , 99 , (int)(100*FIM_THR) ,
04820                           GRA_bkthr_choose_CB , (XtPointer) grapher ) ;
04821    }
04822 
04823    /*** Unimplemented Button ***/
04824 
04825    else {
04826       XBell( grapher->dc->display , 100 ) ;
04827    }
04828 
04829    /*--- Done!!! ---*/
04830 
04831    EXRETURN ;
04832 }

05613 {
05614    MCW_grapher *grapher = (MCW_grapher *) cd ;
05615    XmString xstr ;
05616    char str[32] ;
05617 
05618 ENTRY("GRA_finalize_global_baseline_CB") ;
05619 
05620    if( !GRA_VALID(grapher) ) EXRETURN ;
05621 
05622    grapher->global_base = cbs->fval ;
05623    if( grapher->common_base == BASELINE_GLOBAL ) redraw_graph(grapher,0) ;
05624 
05625    strcpy(str,"Global:") ;
05626    AV_fval_to_char(grapher->global_base,str+7) ;
05627    xstr = XmStringCreateLtoR( str,XmFONTLIST_DEFAULT_TAG ) ;
05628    XtVaSetValues( grapher->opt_baseline_global_label ,
05629                      XmNlabelString,xstr ,
05630                   NULL ) ;
05631    XmStringFree(xstr) ;
05632    EXRETURN ;
05633 }

05707 {
05708    int igtop ;
05709 
05710 ENTRY("GRA_fix_optmenus") ;
05711 
05712    if( ! GRA_REALZ(grapher) ) EXRETURN ;
05713 
05714    /** matrix selection **/
05715 
05716    if( grapher->opt_mat_choose_av->imax != grapher->mat_max )
05717       refit_MCW_optmenu( grapher->opt_mat_choose_av ,
05718                          1 , grapher->mat_max , grapher->mat , 0 ,
05719                          NULL , NULL ) ;
05720 
05721    else
05722       AV_assign_ival( grapher->opt_mat_choose_av , grapher->mat ) ;
05723 
05724    /** slice selection **/
05725 
05726    if( grapher->opt_slice_choose_av->imax != grapher->status->nz-1 )
05727       refit_MCW_optmenu( grapher->opt_slice_choose_av ,
05728                          0, grapher->status->nz - 1, grapher->zpoint, 0,
05729                          NULL , NULL ) ;
05730 
05731    else
05732       AV_assign_ival( grapher->opt_slice_choose_av , grapher->zpoint ) ;
05733 
05734    /** fim ignoration **/
05735 
05736    igtop = MIN( grapher->status->num_series-2 , 99 ) ;
05737    igtop = MAX( igtop , 1 ) ;
05738 
05739    if( grapher->fmenu->fim_ignore_choose_av->imax != igtop )
05740       refit_MCW_optmenu( grapher->fmenu->fim_ignore_choose_av ,
05741                          0 , igtop , grapher->init_ignore, 0,
05742                          NULL , NULL ) ;
05743    else
05744       AV_assign_ival( grapher->fmenu->fim_ignore_choose_av , grapher->init_ignore ) ;
05745 
05746    /** 27 May 1999: fim polort **/
05747 
05748    AV_assign_ival( grapher->fmenu->fim_polort_choose_av , grapher->polort ) ;
05749 
05750    EXRETURN ;
05751 }

03636 {
03637    int ii , npt , nx , ibot , nover=0 , pbot,ptop ;
03638    float top,bot , fac ;
03639    float * xxx ;
03640 
03641 ENTRY("GRA_fixup_xaxis") ;
03642 
03643    if( !GRA_VALID(grapher) || grapher->xax_tsim == NULL ) EXRETURN ;
03644 
03645    ptop = TTOP(grapher) ; pbot = TBOT(grapher) ;
03646    npt = ptop ; nx = grapher->xax_tsim->nx ; npt = MIN(npt,nx) ;
03647    xxx = MRI_FLOAT_PTR(grapher->xax_tsim) ;
03648 
03649    ibot = grapher->init_ignore ;
03650    if( ibot >= npt-1 ) ibot = 0 ;
03651    ibot = MAX(ibot,pbot) ;
03652 
03653    /* find range over plotting interval (ibot..npt-1) */
03654 
03655    top = -WAY_BIG ; bot = WAY_BIG ;
03656    for( ii=ibot ; ii < npt ; ii++ ){
03657      if( xxx[ii] < WAY_BIG ){
03658        top = MAX(top,xxx[ii]) ; bot = MIN(bot,xxx[ii]) ;
03659      } else {
03660        nover++ ;
03661      }
03662    }
03663    if( bot >= top ){
03664      mri_free(grapher->xax_tsim) ;
03665      grapher->xax_tsim = NULL ;
03666      EXRETURN ;
03667    }
03668 
03669    /* scale all of the timeseries */
03670 
03671    fac = 1.0 / (top-bot) ;
03672    for( ii=0 ; ii < nx ; ii++ ){
03673      if( xxx[ii] < WAY_BIG ) xxx[ii] = fac * (xxx[ii]-bot) ;
03674      else                    xxx[ii] = 0.0 ;
03675    }
03676 
03677    EXRETURN ;
03678 }

05756 {
05757    FIM_menu *fmenu = (FIM_menu *) cd ;
05758 
05759 ENTRY("GRA_fmenu_av_CB") ;
05760    fmenu->cbfunc( av->wrowcol , cd , NULL ) ;
05761    EXRETURN ;
05762 }

03813 {
03814    MCW_grapher *grapher = (MCW_grapher *) cd ;
03815    int gg ;
03816 
03817 ENTRY("GRA_ggap_CB") ;
03818 
03819    if( ! GRA_VALID(grapher) ) EXRETURN ;
03820 
03821    gg = grapher->ggap ; grapher->ggap = cbs->ival ;
03822    if( gg != grapher->ggap ){
03823      init_mat( grapher ) ; redraw_graph( grapher , 0 ) ;
03824    }
03825 
03826    EXRETURN ;
03827 }

03774 {
03775    MCW_grapher *grapher = (MCW_grapher *) cd ;
03776 
03777 ENTRY("GRA_grid_choose_CB") ;
03778 
03779    if( ! GRA_VALID(grapher) ) EXRETURN ;
03780    grapher->grid_spacing = cbs->ival ;
03781    grapher->grid_fixed   = 1 ;  /* 02 Apr 2004 */
03782    redraw_graph(grapher,0) ;
03783    EXRETURN ;
03784 }

03832 {
03833    MCW_grapher *grapher = (MCW_grapher *) cd ;
03834    int gg ;
03835 
03836 ENTRY("GRA_gthick_CB") ;
03837 
03838    if( ! GRA_VALID(grapher) ) EXRETURN ;
03839 
03840    gg = grapher->gthick ; grapher->gthick = cbs->ival ;
03841    if( gg != grapher->gthick ){
03842      init_mat( grapher ) ; redraw_graph( grapher , 0 ) ;
03843    }
03844 
03845    EXRETURN ;
03846 }

03122 {
03123    int ii ;
03124 
03125 ENTRY("GRA_handle_keypress") ;
03126 
03127    if( buf[0] == '\0' ) EXRETURN ;
03128 
03129 if(PRINT_TRACING){
03130 char str[256] ;
03131 sprintf(str,"buf[0]=%c (%x)",(int)buf[0],(int)buf[0]) ;
03132 STATUS(str); }
03133 
03134    /*** deal with the key sequence 'N <digits> <Enter>' ***/
03135 
03136    /* first 'N' */
03137 
03138    if( grapher->key_Nlock==0 && buf[0]=='N' ){
03139      grapher->key_Nlock = 1 ;
03140      HAND_cursorize( grapher->fdw_graph ) ;
03141      HAND_cursorize( grapher->draw_fd ) ;
03142      grapher->key_lock_sum = 0 ;
03143      EXRETURN ;
03144    }
03145 
03146    /* last <Enter> */
03147 
03148    if( grapher->key_Nlock && buf[0] == 13 ){
03149 
03150       /* if have a number, set the graph matrix size */
03151 
03152       if( grapher->key_lock_sum > 0 )
03153          grapher->mat = MIN( grapher->mat_max , grapher->key_lock_sum ) ;
03154 
03155       NORMAL_cursorize( grapher->fdw_graph ) ;
03156       if( ISONE(grapher) )
03157         NORMAL_cursorize( grapher->draw_fd ) ;
03158       else
03159         POPUP_cursorize( grapher->draw_fd ) ;
03160 
03161       init_mat    ( grapher ) ;
03162       redraw_graph( grapher , 0 ) ;
03163       send_newinfo( grapher ) ;
03164       grapher->key_Nlock = grapher->key_lock_sum = 0 ;
03165       EXRETURN ;
03166    }
03167 
03168    /* intermediate <digit> */
03169 
03170    if( grapher->key_Nlock ){
03171       if( isdigit(buf[0]) ){
03172          ii = buf[0] - 48;
03173          grapher->key_lock_sum = MIN( 10000, 10*grapher->key_lock_sum + ii ) ;
03174       }
03175       EXRETURN ;
03176    }
03177 
03178    /*-- other keys are single stroke commands --*/
03179 
03180    MCW_discard_events( grapher->draw_fd , KeyPressMask ) ;
03181 
03182    switch (buf[0]) {
03183 
03184       case '-':
03185       case '+':
03186         if( buf[0] == '-' ) scale_down( grapher ) ;
03187         else                scale_up  ( grapher ) ;
03188         redraw_graph( grapher , 0 ) ;
03189       break;
03190 
03191       case 'a':
03192         redraw_graph( grapher , PLOTCODE_AUTOSCALE ) ;         /* 03 Feb 1998 */
03193       break ;
03194 
03195       case 'i':
03196         if( !grapher->textgraph && grapher->init_ignore > 0 ){ /* 24 May 2005 */
03197           GRA_cbs cbs ;
03198           cbs.reason = graCR_setignore ; cbs.key = grapher->init_ignore - 1 ;
03199           CALL_sendback( grapher , cbs ) ;
03200         } else {
03201           XBell(grapher->dc->display,100) ;
03202         }
03203       break ;
03204 
03205       case 'I':
03206         if( !grapher->textgraph ){                             /* 24 May 2005 */
03207           GRA_cbs cbs ;
03208           cbs.reason = graCR_setignore ; cbs.key = grapher->init_ignore + 1 ;
03209           CALL_sendback( grapher , cbs ) ;
03210         } else {
03211           XBell(grapher->dc->display,100) ;
03212         }
03213       break ;
03214 
03215       case 'm':
03216       case 'M':
03217         if( buf[0] == 'm' ) mat_down( grapher ) ;
03218         else                mat_up  ( grapher ) ;
03219         send_newinfo( grapher ) ;
03220       break;
03221 
03222       case 'g':
03223         grid_down( grapher ) ;
03224       break;
03225 
03226       case 'G':
03227         grid_up( grapher ) ;
03228       break;
03229 
03230       case 'h':   /* 05 Jan 1999 */
03231         grapher->HorZ = ! grapher->HorZ ;
03232         redraw_graph( grapher , 0 ) ;
03233       break ;
03234 
03235       case 'q':
03236       case 'Q':
03237         end_fd_graph_CB( NULL , (XtPointer) grapher , NULL ) ;
03238       break ;
03239 
03240       /* modified 07 Aug 2001 to account for more complex baseline scenario */
03241 
03242       case 'b':{
03243         int bbb = grapher->common_base << 1 ;
03244         if( bbb > BASELINE_GLOBAL ) bbb = BASELINE_INDIVIDUAL ;
03245         MCW_set_bbox( grapher->opt_baseline_bbox , bbb ) ;
03246         grapher->common_base = bbb ;
03247         redraw_graph( grapher , 0 ) ;
03248       }
03249       break ;
03250 
03251       case 't':{                                                  /* 22 Sep 2000 */
03252         int bbb = ! grapher->textgraph ;
03253         MCW_set_bbox( grapher->opt_textgraph_bbox , bbb ) ;
03254         grapher->textgraph = bbb ;
03255         redraw_graph( grapher , 0 ) ;
03256       }
03257       break ;
03258 
03259       case 'S':
03260         MCW_choose_string( grapher->option_rowcol ,
03261                            "Save PNM Prefix:" , NULL ,
03262                            GRA_saver_CB , (XtPointer) grapher ) ;
03263       break ;
03264 
03265       case 'L':
03266         show_grapher_pixmap = ! show_grapher_pixmap ;
03267         if( grapher->glogo_pixmap != XmUNSPECIFIED_PIXMAP )
03268            redraw_graph( grapher , 0 ) ;
03269       break ;
03270 
03271       case '<': case ',':   /* change time point */
03272       case '>': case '.':
03273       case '1':
03274       case 'l':
03275          EXRONE(grapher) ;  /* 22 Sep 2000 */
03276 
03277               if( buf[0] == '<' || buf[0] == ',' ) ii = grapher->time_index - 1;
03278          else if( buf[0] == '>' || buf[0] == '.' ) ii = grapher->time_index + 1;
03279          else if( buf[0] == '1'                  ) ii = 1 ;
03280          else if( buf[0] == 'l'                  ) ii = grapher->status->num_series-1;
03281 
03282          ii = (ii+grapher->status->num_series) % grapher->status->num_series ;
03283          if( ii >= 0 && ii < grapher->status->num_series ){
03284            if( grapher->status->send_CB != NULL ){
03285              GRA_cbs cbs ;
03286 
03287              cbs.reason = graCR_setindex ;
03288              cbs.key    = ii;
03289              cbs.event  = NULL ;
03290 #if 0
03291              grapher->status->send_CB( grapher, grapher->getaux, &cbs ) ;
03292 #else
03293              CALL_sendback( grapher , cbs ) ;
03294 #endif
03295            } else {
03296              (void) drive_MCW_grapher( grapher, graDR_setindex, (XtPointer)ii) ;
03297            }
03298          }
03299       break ;
03300 
03301       case 'v':  /* 04 Dec 2003: video */
03302       case 'V':
03303         if( grapher->status->num_series > 1 ){
03304           grapher->timer_func  = GRA_TIMERFUNC_INDEX ;
03305           grapher->timer_delay = (int) AFNI_numenv("AFNI_VIDEO_DELAY") ;
03306           if( grapher->timer_delay <= 0 ) grapher->timer_delay = 1 ;
03307           grapher->timer_param = (buf[0] == 'v') ? 1 : -1 ;
03308           grapher->timer_id    =
03309            XtAppAddTimeOut( XtWidgetToApplicationContext(grapher->opt_quit_pb),
03310                             grapher->timer_delay , GRA_timer_CB , grapher ) ;
03311         } else {
03312           XBell(grapher->dc->display,100) ;
03313         }
03314       break ;
03315 
03316       case 'r':
03317       case 'R':
03318         if( grapher->status->num_series > 1 ){
03319           grapher->timer_func  = GRA_TIMERFUNC_BOUNCE ;
03320           grapher->timer_delay = (int) AFNI_numenv("AFNI_VIDEO_DELAY") ;
03321           if( grapher->timer_delay <= 0 ) grapher->timer_delay = 1 ;
03322           grapher->timer_param = (buf[0] == 'r') ? 1 : -1 ;
03323           grapher->timer_id    =
03324            XtAppAddTimeOut( XtWidgetToApplicationContext(grapher->opt_quit_pb),
03325                             grapher->timer_delay , GRA_timer_CB , grapher ) ;
03326         } else {
03327           XBell(grapher->dc->display,100) ;
03328         }
03329       break ;
03330 
03331       case 'z':  /* change slice */
03332       case 'Z':
03333         if( buf[0] == 'z' ){
03334           grapher->zpoint -- ;
03335           if( grapher->zpoint < 0 ) grapher->zpoint = grapher->status->nz - 1 ;
03336         } else {
03337           grapher->zpoint ++ ;
03338           if( grapher->zpoint >= grapher->status->nz ) grapher->zpoint = 0 ;
03339         }
03340         redraw_graph( grapher , 0 ) ;
03341         send_newinfo( grapher ) ;
03342       break ;
03343 
03344       case 'w':{
03345          char * wcfname ;
03346          int ndig , ll ;
03347          MRI_IMAGE * tsim ;
03348          int xd,yd,zd ;     /* 24 Sep 1999 */
03349 
03350          EXRONE(grapher) ;  /* 22 Sep 2000 */
03351 
03352          ll   = MAX( grapher->status->nx , grapher->status->ny ) ;
03353          ll   = MAX( grapher->status->nz , ll ) ;
03354          ndig = (ll < 1000) ? 3 : 4 ;
03355 
03356          ll   = 3*ndig + 16 ;
03357          if( Grapher_Stuff.wcsuffix != NULL )
03358             ll += strlen(Grapher_Stuff.wcsuffix) ;
03359          wcfname = (char *) XtMalloc(ll) ;
03360 
03361          /* 24 Sep 1999: mangle the name for the output */
03362 
03363          xd = grapher->xpoint; yd = grapher->ypoint; zd = grapher->zpoint;
03364 #ifndef DONT_MANGLE_XYZ
03365          { THD_ivec3 id;
03366            id = THD_fdind_to_3dind( grapher->getaux, TEMP_IVEC3(xd,yd,zd) );
03367            xd = id.ijk[0]; yd = id.ijk[1]; zd = id.ijk[2]; }
03368 #endif
03369 
03370          if( Grapher_Stuff.wcsuffix != NULL )
03371             sprintf(wcfname,"%0*d_%0*d_%0*d.%s.1D" ,
03372                     ndig,xd , ndig,yd , ndig,zd ,
03373                               Grapher_Stuff.wcsuffix ) ;
03374          else
03375             sprintf(wcfname,"%0*d_%0*d_%0*d.1D" ,
03376                     ndig,xd , ndig,yd , ndig,zd  ) ;
03377 
03378          ll = grapher->xpoint +
03379               grapher->ypoint * grapher->status->nx +
03380               grapher->zpoint * grapher->status->nx * grapher->status->ny ;
03381 
03382 #if 0
03383          tsim  = (MRI_IMAGE *) grapher->getser( ll , graCR_getseries ,
03384                                                      grapher->getaux ) ;
03385 #else
03386          CALL_getser( grapher , ll,graCR_getseries , MRI_IMAGE *,tsim ) ;
03387 #endif
03388 
03389          if( tsim != NULL ){
03390            mri_write_1D( wcfname , tsim ) ;  /* 16 Nov 1999: replaces mri_write_ascii */
03391            mri_free( tsim ) ;
03392          }
03393          myXtFree(wcfname) ;
03394       }
03395       break ;
03396 
03397       /*--- At this point, have a key not handled here.
03398             Call the creator to see if it wishes to deal with it. ---*/
03399 
03400       default:
03401         if( grapher->status->send_CB != NULL ){
03402           GRA_cbs cbs ;
03403 
03404           cbs.reason = graCR_keypress ;
03405           cbs.key    = buf[0] ;
03406           cbs.event  = ev ;
03407 #if 0
03408           grapher->status->send_CB( grapher , grapher->getaux , &cbs ) ;
03409 #else
03410           CALL_sendback( grapher , cbs ) ;
03411 #endif
03412         }
03413       break ;
03414    }
03415 
03416    EXRETURN ;
03417 }

03877 {
03878    MCW_grapher *grapher = (MCW_grapher *) cd ;
03879 
03880 ENTRY("GRA_ignore_choose_CB") ;
03881 
03882    if( ! GRA_VALID(grapher) || grapher->status->send_CB == NULL ) EXRETURN ;
03883 
03884    if( cbs->ival >= 0 && cbs->ival < TTOP(grapher)-1 ){
03885       GRA_cbs gbs ;
03886 
03887       gbs.reason = graCR_setignore ;
03888       gbs.key    = cbs->ival ;
03889 #if 0
03890       grapher->status->send_CB( grapher , grapher->getaux , &gbs ) ;
03891 #else
03892       CALL_sendback( grapher , gbs ) ;
03893 #endif
03894    }
03895    EXRETURN ;
03896 }

05907 {
05908    int ww,hh,xx,yy ;
05909    int pw,ph,px,py ;
05910 
05911 ENTRY("GRA_mapmenu_CB") ;
05912 
05913    if( AFNI_yesenv("AFNI_DONT_MOVE_MENUS") ) EXRETURN ;  /* 08 Aug 2001 */
05914 
05915    MCW_widget_geom( w                     , &ww,&hh , &xx,&yy ) ;
05916    MCW_widget_geom( XtParent(XtParent(w)) , &pw,&ph , &px,&py ) ;
05917 
05918 #if 1
05919 if(PRINT_TRACING){
05920  char str[256] ;
05921  sprintf(str,"menu:   width=%d height=%d x=%d y=%d",ww,hh,xx,yy); STATUS(str);
05922  sprintf(str,"parent: width=%d height=%d x=%d y=%d",pw,ph,px,py); STATUS(str); }
05923 #endif
05924 
05925    pw = pw >> 3 ;
05926    if( ! ( xx > px+7*pw || xx+ww < px+pw ) ){
05927       xx = px - ww ;  if( xx < 0 ) xx = 0 ;
05928 #if 1
05929 if(PRINT_TRACING){
05930  char str[256]; sprintf(str,"moving menu to x=%d",xx); STATUS(str); }
05931 #endif
05932       XtVaSetValues( w , XmNx , xx , NULL ) ;
05933    }
05934 
05935    RWC_xineramize( XtDisplay(w) , xx,yy,ww,hh , &xx,&yy ) ; /* 27 Sep 2000 */
05936    XtVaSetValues( w , XmNx,xx , XmNy,yy , NULL ) ;
05937    EXRETURN ;
05938 }

03742 {
03743    MCW_grapher *grapher = (MCW_grapher *) cd ;
03744 
03745 ENTRY("GRA_mat_choose_CB") ;
03746 
03747    if( ! GRA_VALID(grapher) || cbs->ival < 1 ) EXRETURN ;
03748 
03749    grapher->mat = MIN( grapher->mat_max , cbs->ival ) ;
03750    init_mat    ( grapher ) ;
03751    redraw_graph( grapher , 0 ) ;
03752    send_newinfo( grapher ) ;
03753    EXRETURN ;
03754 }

03076 {
03077    int ww,hh ;
03078 
03079 ENTRY("GRA_new_pixmap") ;
03080 
03081    if( ! GRA_REALZ(grapher) ) EXRETURN ;
03082 
03083    grapher->fWIDE  = new_width ;
03084    grapher->fHIGH  = new_height ;
03085    grapher->gx_max = new_width  - (GL_DLX + GR_DLX) ;
03086    grapher->gy_max = new_height - (GT_DLY + GB_DLY) ;
03087 
03088    if( grapher->fd_pxWind != (Pixmap) 0 ){
03089 STATUS("freeing old Pixmap") ;
03090       XFreePixmap( grapher->dc->display , grapher->fd_pxWind ) ;
03091    }
03092 
03093 STATUS("allocating new Pixmap") ;
03094    grapher->fd_pxWind = XCreatePixmap( grapher->dc->display ,
03095                                        XtWindow(grapher->draw_fd) ,
03096                                        grapher->fWIDE , grapher->fHIGH,
03097                                        grapher->dc->planes ) ;
03098 
03099    MCW_widget_geom( grapher->option_rowcol , &ww , &hh , NULL,NULL ) ;
03100    XtVaSetValues( grapher->option_rowcol ,
03101 #ifdef WANT_AFNI_BITMAP
03102                      XmNx , grapher->fWIDE - ww - 2 ,
03103 #else
03104                      XmNx , 2 ,
03105 #endif
03106                      XmNy , grapher->fHIGH - hh - 2 ,
03107                   NULL ) ;
03108 
03109    if( redraw ){
03110      init_mat( grapher ) ;
03111      redraw_graph( grapher , 0 ) ;
03112    }
03113 
03114    EXRETURN ;
03115 }

03437 {
03438    MCW_grapher * grapher = (MCW_grapher *) client_data ;
03439 
03440 ENTRY("GRA_opt_CB") ;
03441 
03442    if( w == grapher->opt_scale_down_pb ){
03443       GRA_handle_keypress( grapher , "-" , NULL ) ;
03444       EXRETURN ;
03445    }
03446 
03447    if( w == grapher->opt_scale_up_pb ){
03448       GRA_handle_keypress( grapher , "+" , NULL ) ;
03449       EXRETURN ;
03450    }
03451 
03452    if( w == grapher->opt_scale_auto_pb ){
03453       GRA_handle_keypress( grapher , "a" , NULL ) ;
03454       EXRETURN ;
03455    }
03456 
03457    if( w == grapher->opt_grid_down_pb ){
03458       GRA_handle_keypress( grapher , "g" , NULL ) ;
03459       EXRETURN ;
03460    }
03461 
03462    if( w == grapher->opt_grid_up_pb ){
03463       GRA_handle_keypress( grapher , "G" , NULL ) ;
03464       EXRETURN ;
03465    }
03466 
03467    if( w == grapher->opt_grid_auto_pb ){     /* 02 Apr 2004 */
03468      auto_grid( grapher , NPTS(grapher) ) ;
03469      redraw_graph(grapher,0) ;
03470      EXRETURN ;
03471    }
03472 
03473    if( w == grapher->opt_grid_HorZ_pb ){     /* 05 Jan 1999 */
03474       GRA_handle_keypress( grapher , "h" , NULL ) ;
03475       EXRETURN ;
03476    }
03477 
03478    if( w == grapher->opt_slice_down_pb ){
03479       GRA_handle_keypress( grapher , "z" , NULL ) ;
03480       EXRETURN ;
03481    }
03482 
03483    if( w == grapher->opt_slice_up_pb ){
03484       GRA_handle_keypress( grapher , "Z" , NULL ) ;
03485       EXRETURN ;
03486    }
03487 
03488    if( w == grapher->opt_mat_down_pb ){
03489       GRA_handle_keypress( grapher , "m" , NULL ) ;
03490       EXRETURN ;
03491    }
03492 
03493    if( w == grapher->opt_mat_up_pb ){
03494       GRA_handle_keypress( grapher , "M" , NULL ) ;
03495       EXRETURN ;
03496    }
03497 
03498 #if 0
03499    if( w == grapher->opt_color_up_pb ){
03500       GRA_handle_keypress( grapher , "r" , NULL ) ;
03501       EXRETURN ;
03502    }
03503 #endif
03504 
03505    if( w == grapher->opt_quit_pb ){
03506 #if 0
03507       GRA_handle_keypress( grapher , "q" , NULL ) ;
03508 #else
03509 STATUS("User pressed Done button: starting timeout") ;
03510       grapher->valid = 666 ;
03511       (void) XtAppAddTimeOut( XtWidgetToApplicationContext(w) ,
03512                               50 , GRA_quit_timeout_CB , grapher ) ;
03513 #endif
03514       EXRETURN ;
03515    }
03516 
03517    if( w == grapher->opt_save_pb ){
03518       GRA_timer_stop(grapher) ;   /* 04 Dec 2003 */
03519       GRA_handle_keypress( grapher , "S" , NULL ) ;
03520       EXRETURN ;
03521    }
03522 
03523    if( w == grapher->opt_write_center_pb ){
03524       GRA_timer_stop(grapher) ;   /* 04 Dec 2003 */
03525       GRA_handle_keypress( grapher , "w" , NULL ) ;
03526       EXRETURN ;
03527    }
03528 
03529    if( w == grapher->opt_write_suffix_pb ){
03530       EXRONE(grapher) ;  /* 22 Sep 2000 */
03531       GRA_timer_stop(grapher) ;   /* 04 Dec 2003 */
03532       MCW_choose_string( grapher->option_rowcol ,
03533                          "'Write Center' Suffix:" , Grapher_Stuff.wcsuffix ,
03534                          GRA_wcsuffix_choose_CB , NULL ) ;
03535       EXRETURN ;
03536    }
03537 
03538    if( w == grapher->opt_scale_choose_pb ){
03539      MCW_choose_integer( grapher->option_rowcol , "Scale" ,
03540                          -9999 , 9999 , (int)(grapher->fscale) ,
03541                          GRA_scale_choose_CB , (XtPointer) grapher ) ;
03542      EXRETURN ;
03543    }
03544 
03545 #ifndef USE_OPTMENUS
03546    if( w == grapher->opt_mat_choose_pb ){
03547      MCW_choose_integer( grapher->option_rowcol , "Matrix" ,
03548                          1 , grapher->mat_max , grapher->mat ,
03549                          GRA_mat_choose_CB , (XtPointer) grapher ) ;
03550      EXRETURN ;
03551    }
03552 #endif
03553 
03554    if( w == grapher->opt_grid_choose_pb ){
03555      MCW_choose_integer( grapher->option_rowcol , "Grid" ,
03556                          grid_ar[0] , grid_ar[GRID_MAX-1] , grapher->grid_spacing ,
03557                          GRA_grid_choose_CB , (XtPointer) grapher ) ;
03558      EXRETURN ;
03559    }
03560 
03561    if( w == grapher->opt_pin_choose_pb ){   /* 19 Mar 2004 */
03562      char *lvec[2] = { "Bot" , "Top" } ;
03563      int   ivec[2] ;
03564      ivec[0] = grapher->pin_bot ; ivec[1] = grapher->pin_top ;
03565      MCW_choose_vector( grapher->option_rowcol , "Graph Pins: Bot..Top-1" ,
03566                         2 , lvec,ivec ,
03567                         GRA_pin_choose_CB , (XtPointer) grapher ) ;
03568      EXRETURN ;
03569    }
03570 
03571 #ifndef USE_OPTMENUS
03572    if( w == grapher->opt_slice_choose_pb && grapher->status->nz > 1 ){
03573      MCW_choose_integer( grapher->option_rowcol , "Slice" ,
03574                          0 , grapher->status->nz - 1 , grapher->zpoint ,
03575                          GRA_slice_choose_CB , (XtPointer) grapher ) ;
03576      EXRETURN ;
03577    }
03578 #endif
03579 
03580    /*** 09 Jan 1998: x-axis stuff ***/
03581 
03582    if( w == grapher->opt_xaxis_clear_pb ){
03583      mri_free( grapher->xax_tsim ) ;
03584      grapher->xax_tsim = NULL ;
03585      GRA_timer_stop(grapher) ;   /* 04 Dec 2003 */
03586      redraw_graph( grapher , 0 ) ;
03587      EXRETURN ;
03588    }
03589 
03590    if( w == grapher->opt_xaxis_pick_pb ){
03591      GRA_timer_stop(grapher) ;   /* 04 Dec 2003 */
03592      if( IMARR_COUNT(GLOBAL_library.timeseries) > 0 ){
03593        MCW_choose_timeseries( grapher->fdw_graph , "Graph x-axis" ,
03594                               GLOBAL_library.timeseries , -1 ,
03595                               GRA_pick_xaxis_CB , (XtPointer) grapher ) ;
03596      } else {
03597        (void) MCW_popup_message(
03598                  grapher->option_rowcol ,
03599                  "No timeseries library\nexists to pick from!" ,
03600                  MCW_USER_KILL | MCW_TIMER_KILL ) ;
03601      }
03602      EXRETURN ;
03603    }
03604 
03605    if( w == grapher->opt_xaxis_center_pb ){
03606      EXRONE(grapher) ;  /* 22 Sep 2000 */
03607      GRA_timer_stop(grapher) ;   /* 04 Dec 2003 */
03608      if( grapher->cen_tsim != NULL ){
03609        mri_free( grapher->xax_tsim ) ;
03610        grapher->xax_tsim = mri_to_float( grapher->cen_tsim ) ;
03611        redraw_graph(grapher,0) ;
03612      } else {
03613        XBell(XtDisplay(w),100) ;
03614      }
03615      EXRETURN ;
03616    }
03617 
03618    /** 07 Aug 2001: Set Global baseline **/
03619 
03620    if( w == grapher->opt_baseline_setglobal_pb ){
03621      MCW_choose_integer( grapher->option_rowcol , "Global Baseline" ,
03622                          -29999 , 29999 , (int)(grapher->global_base) ,
03623                          GRA_finalize_global_baseline_CB ,
03624                          (XtPointer) grapher ) ;
03625      EXRETURN ;
03626    }
03627 
03628    /** shouldn't get to here, but who knows? **/
03629 
03630    EXRETURN ;
03631 }

01159 {
01160    int  i, ncirc ;
01161    XPoint a[NBTOP] ;
01162 
01163    switch( filled ){
01164       default: ncirc = NCIR ; break ;
01165       case 1:  ncirc = NBAL ; break ;
01166       case 2:  ncirc = NBAX ; break ;
01167    }
01168 
01169    for( i=0 ; i < ncirc ; i++ ){
01170       a[i].x = xball[i].x + xwin ;
01171       a[i].y = xball[i].y + ywin ;
01172    }
01173 
01174    DC_linewidth( grapher->dc, 0 ) ;
01175 
01176    XDrawPoints( grapher->dc->display, XtWindow(grapher->draw_fd),
01177                 grapher->dc->myGC, a, ncirc, CoordModeOrigin ) ;
01178    return ;
01179 }

03683 {
03684    MCW_grapher *grapher = (MCW_grapher *) cd ;
03685    int its ;
03686    MRI_IMAGE *tsim ;
03687 
03688 ENTRY("GRA_pick_xaxis_CB") ;
03689 
03690    if( !GRA_VALID(grapher) || cbs->reason != mcwCR_timeseries ) EXRETURN ;
03691    GRA_timer_stop( grapher ) ;
03692 
03693    its = cbs->ival ;
03694    if( its >= 0 && its < IMARR_COUNT(GLOBAL_library.timeseries) ){
03695      tsim = IMARR_SUBIMAGE(GLOBAL_library.timeseries,its) ;
03696      mri_free( grapher->xax_tsim ) ;
03697      grapher->xax_tsim = mri_to_float(tsim) ;
03698      redraw_graph( grapher , 0 ) ;
03699    }
03700 
03701    EXRETURN ;
03702 }

03789 {
03790    MCW_grapher *grapher = (MCW_grapher *) cd ;
03791    float *vec = (float *)(cbs->cval) ;
03792    int pb=(int)vec[0] , pt=(int)vec[1] , ii ;
03793 
03794 ENTRY("GRA_pin_choose_CB") ;
03795 
03796    GRA_timer_stop( grapher ) ;
03797 
03798    if( pb >= grapher->status->num_series-2 ||
03799        pb <  0                             ||
03800        (pt > 0 && pt-pb < 2)                 ){   /* stupid user */
03801 
03802       XBell(grapher->dc->display,100) ; EXRETURN ;
03803    }
03804 
03805    ii = 100000*pt + pb ;
03806    drive_MCW_grapher( grapher , graDR_setpins , (XtPointer)(ii) ) ;
03807    EXRETURN ;
03808 }

03905 {
03906    MCW_grapher * grapher = (MCW_grapher *) cd ;
03907 
03908 ENTRY("GRA_polort_choose_CB") ;
03909 
03910    if( ! GRA_VALID(grapher) || grapher->status->send_CB == NULL ) EXRETURN ;
03911 
03912    if( cbs->ival >= 0 && cbs->ival <= MAX_POLORT ){
03913       GRA_cbs gbs ;
03914 
03915       gbs.reason = graCR_polort ;
03916       gbs.key    = cbs->ival ;
03917 #if 0
03918       grapher->status->send_CB( grapher , grapher->getaux , &gbs ) ;
03919 #else
03920       CALL_sendback( grapher , gbs ) ;
03921 #endif
03922    }
03923    EXRETURN ;
03924 }

03424 {
03425    MCW_grapher * grapher = (MCW_grapher *) client_data ;
03426 
03427 ENTRY("GRA_quit_timeout_CB") ;
03428    GRA_handle_keypress( grapher , "q" , NULL ) ;
03429    EXRETURN ;
03430 }

01209 {
01210    Window    win ;
01211    Display * dis ;
01212    int       ii , xxx , jj ;
01213    float     val ;
01214    char buf[16] , strp[128] ;
01215    char * vbuf , *iname , *vname ;
01216 
01217 ENTRY("GRA_redraw_overlay") ;
01218 
01219    if( ! GRA_REALZ(grapher) ){ STATUS("ILLEGAL CALL") ; EXRETURN ; }
01220 
01221    if( ! MCW_widget_visible(grapher->draw_fd) ) EXRETURN ;  /* 03 Jan 1999 */
01222    if( grapher->dont_redraw ) EXRETURN ;                    /* 27 Jan 2004 */
01223 
01224    /* erase contents of window (that aren't in the pixmap) */
01225 
01226    dis = grapher->dc->display ;
01227    win = XtWindow(grapher->draw_fd) ;
01228    XClearWindow( dis , win ) ;
01229 
01230    EXRONE(grapher) ;  /* 22 Sep 2000 */
01231 
01232    /* draw some circles over ignored data points [23 May 2005] */
01233 
01234    if( grapher->init_ignore > 0 && !grapher->textgraph ){
01235      DC_fg_color( grapher->dc , IGNORE_COLOR(grapher) ) ;
01236      jj  = NBOT(grapher) ;                     /* first point to plot */
01237      xxx = NTOP(grapher) ;                     /* last */
01238      xxx = MIN (xxx , grapher->init_ignore) ;  /* point */
01239      xxx = MIN (xxx , ii+grapher->nncen) ;     /* to plot */
01240      for( ii=jj ; ii < xxx ; ii++ )
01241 #if 0
01242        GRA_overlay_circle( grapher , grapher->cen_line[ii-jj].x ,
01243                                      grapher->cen_line[ii-jj].y , 1 ) ;
01244 #else
01245        GRA_draw_circle( grapher , grapher->cen_line[ii-jj].x ,
01246                                   grapher->cen_line[ii-jj].y , 4 ) ;
01247 #endif
01248    }
01249 
01250    /* 22 July 1996:
01251       draw a ball on the graph at the currently display time_index */
01252 
01253    ii = grapher->time_index ; jj = NBOT(grapher) ;
01254    if( ii >= jj            &&
01255        ii <  NTOP(grapher) && ii-jj < grapher->nncen && !grapher->textgraph ){
01256 
01257       DC_fg_color( grapher->dc , IDEAL_COLOR(grapher) ) ;
01258       GRA_overlay_circle( grapher , grapher->cen_line[ii-jj].x ,
01259                                     grapher->cen_line[ii-jj].y , 2 ) ;
01260    }
01261 
01262    /* draw text showing value at currently displayed time_index */
01263 
01264    if( ii >= 0 && grapher->cen_tsim != NULL && ii < grapher->cen_tsim->nx ){
01265       val = MRI_FLOAT_PTR(grapher->cen_tsim)[ii] ;
01266       AV_fval_to_char( val , buf ) ;
01267       vbuf = (buf[0]==' ') ? buf+1 : buf ;
01268 
01269       if( grapher->fWIDE < SHORT_NAME_WIDTH ){
01270         iname = short_index_name ; vname = short_value_name ;
01271       } else {
01272         iname = long_index_name ; vname = long_value_name ;
01273       }
01274 
01275       sprintf( strp , "%s%d%s%s" , iname,ii , vname,vbuf ) ;
01276 
01277       if( grapher->cen_tsim->dx != 0.0 ){
01278         val = grapher->cen_tsim->xo + ii * grapher->cen_tsim->dx ;
01279         AV_fval_to_char( val , buf ) ;
01280         vbuf = (buf[0]==' ') ? buf+1 : buf ;
01281         ii = strlen(strp) ;
01282         sprintf( strp+ii , "%s%s" ,
01283                  (grapher->fWIDE < SHORT_NAME_WIDTH) ? short_time_name
01284                                                      : long_time_name, vbuf ) ;
01285       }
01286 
01287       xxx = MAX( grapher->xx_text_2 ,
01288                  grapher->xorigin[grapher->xc][grapher->yc] ) ;
01289 
01290       if( grapher->init_ignore > 0 ) xxx = MAX( xxx , grapher->xx_text_2p ) ;
01291 
01292       DC_fg_color( grapher->dc , IDEAL_COLOR(grapher) ) ;
01293       overlay_txt( grapher, xxx , GB_DLY-15 , strp ) ;
01294    }
01295 
01296    /* no more to do now */
01297 
01298    XFlush( dis ) ;
01299    EXRETURN ;
01300 }

03938 {
03939    MCW_grapher * grapher = (MCW_grapher *) cd ;
03940    MRI_IMAGE * flim ;
03941    float * far ;
03942    int ii ;
03943    GRA_cbs gbs ;
03944 
03945 ENTRY("GRA_refread_choose_CB") ;
03946 
03947    if( ! GRA_VALID(grapher)             ||
03948        grapher->status->send_CB == NULL ||
03949        cbs->reason != mcwCR_string      ||
03950        cbs->cval == NULL                || strlen(cbs->cval) == 0 ) EXRETURN ;
03951 
03952    EXRONE(grapher) ;  /* 22 Sep 2000 */
03953 
03954    flim = mri_read_1D( cbs->cval ) ;     /* 16 Nov 1999: replaces mri_read_ascii */
03955    if( flim == NULL || flim->nx < 2 ){
03956       XBell(grapher->dc->display,100) ; mri_free(flim) ; EXRETURN ;
03957    }
03958 
03959    far = MRI_FLOAT_PTR(flim) ;
03960    for( ii=0 ; ii < flim->nvox ; ii++ )
03961       if( fabs(far[ii]) >= 33333.0 ) far[ii] = WAY_BIG ;
03962 
03963    { GRA_cbs cbs; cbs.reason=graCR_winaver; CALL_sendback(grapher,cbs); }
03964    MCW_set_bbox( grapher->fmenu->fim_editref_winaver_bbox , 0 ) ;
03965    gbs.reason   = graCR_refequals ;
03966    gbs.userdata = (XtPointer) flim ;
03967 #if 0
03968    grapher->status->send_CB( grapher , grapher->getaux , &gbs ) ;
03969 #else
03970    CALL_sendback( grapher , gbs ) ;
03971 #endif
03972    mri_free(flim) ;
03973    EXRETURN ;
03974 }

03979 {
03980    MCW_grapher * grapher = (MCW_grapher *) cd ;
03981 
03982 ENTRY("GRA_refstore_choose_CB") ;
03983 
03984    if( ! GRA_VALID(grapher)             ||
03985        grapher->ref_ts == NULL          ||
03986        IMARR_COUNT(grapher->ref_ts) < 1 ||
03987        cbs->reason != mcwCR_string      ||
03988        cbs->cval == NULL                || strlen(cbs->cval) == 0 ) EXRETURN ;
03989 
03990    EXRONE(grapher) ;  /* 22 Sep 2000 */
03991 
03992    PLUTO_register_timeseries( cbs->cval , IMARR_SUBIMAGE(grapher->ref_ts,0) ) ;
03993    EXRETURN ;
03994 }

03999 {
04000    MCW_grapher * grapher = (MCW_grapher *) cd ;
04001    MRI_IMAGE * tsim ;
04002    int ii , ll ;
04003    GRA_cbs gbs ;
04004 
04005 ENTRY("GRA_refwrite_choose_CB") ;
04006 
04007    if( ! GRA_VALID(grapher)             ||
04008        grapher->ref_ts == NULL          ||
04009        IMARR_COUNT(grapher->ref_ts) < 1 ||
04010        cbs->reason != mcwCR_string      ||
04011        cbs->cval == NULL                || (ll=strlen(cbs->cval)) == 0 ) EXRETURN ;
04012 
04013    EXRONE(grapher) ;  /* 22 Sep 2000 */
04014 
04015    for( ii=0 ; ii < ll ; ii++ ){
04016       if( iscntrl(cbs->cval[ii]) || isspace(cbs->cval[ii]) ||
04017           cbs->cval[ii] == '/'   || cbs->cval[ii] == ';'   ||
04018           cbs->cval[ii] == '*'   || cbs->cval[ii] == '?'   ||
04019           cbs->cval[ii] == '&'   || cbs->cval[ii] == '|'   ||
04020           cbs->cval[ii] == '"'   || cbs->cval[ii] == '>'   ||
04021           cbs->cval[ii] == '<'   || cbs->cval[ii] == '\''  ||
04022           cbs->cval[ii] == '['   || cbs->cval[ii] == ']'     ){
04023 
04024          XBell( XtDisplay(wcaller) , 100 ) ; EXRETURN ;
04025       }
04026    }
04027 
04028 #if 0
04029    tsim = mri_transpose( IMARR_SUBIMAGE(grapher->ref_ts,0) ) ;
04030    mri_write_ascii( cbs->cval , tsim ) ;
04031    mri_free( tsim ) ;
04032 #else
04033    mri_write_1D( cbs->cval , IMARR_SUBIMAGE(grapher->ref_ts,0) ) ; /* 16 Nov 1999 */
04034 #endif
04035 
04036    /* 12 Nov 1996: put this in AFNI's list of library files */
04037 
04038    if( grapher->status->send_CB != NULL ){
04039       mri_add_name( cbs->cval , IMARR_SUBIMAGE(grapher->ref_ts,0) ) ;
04040       gbs.reason   = graCR_timeseries_library ;
04041       gbs.userdata = (XtPointer) IMARR_SUBIMAGE(grapher->ref_ts,0) ;
04042 #if 0
04043       grapher->status->send_CB( grapher , grapher->getaux , &gbs ) ;
04044 #else
04045       CALL_sendback( grapher , gbs ) ;
04046 #endif
04047    }
04048    EXRETURN ;
04049 }

05833 {
05834    int ll , ii ;
05835    MCW_grapher * grapher = (MCW_grapher *) cd ;
05836    char * fname , * ppnm ;
05837 
05838 ENTRY("GRA_saver_CB") ;
05839 
05840    if( ! GRA_REALZ(grapher) ) EXRETURN ;
05841 
05842    if( cbs->reason != mcwCR_string ||
05843        cbs->cval   == NULL         || (ll=strlen(cbs->cval)) == 0 ){
05844 
05845       XBell( XtDisplay(wcaller) , 100 ) ; EXRETURN ;
05846    }
05847 
05848    fname = (char *) malloc( sizeof(char) * (ll+8) ) ;
05849    strcpy( fname , cbs->cval ) ;
05850 
05851    for( ii=0 ; ii < ll ; ii++ )
05852       if( iscntrl(fname[ii]) || isspace(fname[ii]) ) break ;
05853 
05854    if( ii < ll || ll < 2 || ll > 240 ){
05855       XBell( XtDisplay(wcaller) , 100 ) ;
05856       free( fname ) ; EXRETURN ;
05857    }
05858 
05859                       ppnm = strstr( fname , ".ppm" ) ;
05860    if( ppnm == NULL ) ppnm = strstr( fname , ".pnm" ) ;
05861    if( ppnm == NULL ) ppnm = strstr( fname , ".jpg" ) ;
05862    if( ppnm == NULL ) strcat(fname,".ppm") ;
05863 
05864    GRA_file_pixmap( grapher , fname ) ;
05865    POPDOWN_string_chooser ;
05866    free(fname) ; EXRETURN ;
05867 }