{\
  XtVaSetValues(  SO->SurfCont->thr_sc, XmNheight,  SUMA_CMAP_HEIGHT, NULL ) ;   \
}

{  \
   if (TF->str_value) { \
      SUMA_STRING_REPLACE(TF->str_value[j*TF->Ni+i], strng);\
   }  \
   XtVaSetValues (TF->cells[j*TF->Ni+i], XmNvalue, strng, NULL);  \
}

{  \
   if (TF->type == SUMA_int || TF->type == SUMA_float) { \
      TF->cell_modified = j*TF->Ni+i;  \
      TF->num_value[TF->cell_modified] = val;  \
      SUMA_TableF_SetString(TF);\
      TF->cell_modified = -1; \
   }  else {   \
      SUMA_SL_Err("Macro for numerical tables only"); \
   }  \
}

{  \
      int m_loc[2];  \
      if (SUMA_GetDsetColRange(m_dset, m_i, m_range, m_loc)) {   \
         SUMA_SurfaceObject *m_SOp = NULL;   \
         char *m_idcode_str = NULL; \
         int m_N_Node=-1;  \
             \
         m_idcode_str = NI_get_attribute(m_dset->ngr, "MeshParent_idcode");  \
         if (!m_idcode_str) m_idcode_str = NI_get_attribute(m_dset->ngr, "Parent_ID"); \
         if (m_idcode_str) { \
            m_SOp = SUMA_findSOp_inDOv(m_idcode_str, SUMAg_DOv, SUMAg_N_DOv);  \
            if (m_SOp) {  \
               m_N_Node = m_SOp->N_Node;   \
            }  \
         }  \
         sprintf(m_str_min, "%s", MV_format_fval2(m_range[0], 7));   \
         sprintf(m_str_max, "%s", MV_format_fval2(m_range[1], 7));   \
         sprintf(m_str_minloc, "%d", SUMA_GetNodeIndex_FromNodeRow(m_dset, m_loc[0], m_N_Node));   \
         sprintf(m_str_maxloc, "%d", SUMA_GetNodeIndex_FromNodeRow(m_dset, m_loc[1], m_N_Node));   \
      } else { \
         sprintf(m_str_min, "???");   \
         sprintf(m_str_max, "???");   \
         sprintf(m_str_minloc, "???");   \
         sprintf(m_str_maxloc, "???");   \
      }  \
   }

"Toggle Absolute thresholding.\n"   \
   "OFF: Mask node color for\n"   \
   "     nodes that have:  \n"   \
   "     T(n) < Tscale\n"   \
   "ON:  Mask node color for\n"   \
   "     nodes that have:\n"   \
   "     | T(n) | < Tscale\n"   \
   "where:\n"   \
   "Tscale is the value set by\n"   \
   "       the threshold scale.\n"   \
   "T(n) is the node value in the \n"   \
   "     selected threshold column (T).\n"   \
   "     this value is seen in the \n"   \
   "     second cell of the 'Value'\n"   \
   "     table on the left side."

"Coordinate bias direction.\n"   \
   "   -: No bias thank you\n"   \
   "   x: X coord bias\n"   \
   "   y: Y coord bias\n"   \
   "   z: Z coord bias\n"   \
   "   n: bias along node's normal\n"  \
   "\n"   \
   "See more info in Bhelp for\n"   \
   "'C' table entry above.\n" \
   "\n"   \
   "This option will produce\n"   \
   "'Extremely Cool'[1] images.\n"   \
   "[1] Chuck E. Weiss (Slow River/\n" \
   "    Rykodisc) 1999."

"Switch between available color maps.\n"   \
   "If the number of colormaps is too large\n"   \
   "for the menu button, right click over\n"   \
   "the 'Cmp' label and a chooser with a \n"   \
   "slider bar will appear.\n"   \
   "\n"   \
   "More help is available via\n"   \
   "ctrl+h while mouse is over the\n"   \
   "colormap."

"Load new colormap.\n"   \
   "Loaded map will replace a\n"   \
   "pre-existing one with the\n"   \
   "same name.\n"   \
   "\n"   \
   "See ScaleToMap -help for \n"   \
   "details on the format of \n"   \
   "colormap file. The formats\n"   \
   "are described in the section\n"   \
   "for the option -cmapfile.\n"   \
   "\n"   \
   "A sample colormap would be:\n"   \
   " 0 0 1\n"   \
   " 1 1 1\n"   \
   " 1 0 0\n"   \
   "saved into a cmap file called\n"   \
   "cmap_test.1D.cmap"

"Switch between color mapping modes.\n"   \
   "Int: Interpolate linearly between\n"   \
   "     colors in colormap\n"   \
   "NN : Use the nearest color in the\n"   \
   "     colormap. \n"   \
   "Dir: Use intensity values as indices\n"   \
   "     into the colormap.\n"   \
   "     In Dir mode, the intensity \n"   \
   "     clipping range is of no use."

"Dimming factor to apply to colormap\n" \
   "before mapping the intensity (I) data.\n" \
   "The colormap, if displayed on the right,\n"   \
   "is not visibly affected by Dim but the\n"   \
   "colors mapped onto the surface are.\n"   \
   "For RGB Dsets (.col files), Dim is\n" \
   "applied to the RGB colors directly"

"Load a new color plane.\n"   \
   "(Same as ctrl+c option)."

"Opacity of Dset's colorplane.\n"  \
   "Opaque planes have an opacity\n"   \
   "of 1, transparent planes have\n"  \
   "an opacity of 0. \n"   \
   "Opacities are used when mixing\n" \
   "planes within the same group  \n"  \
   "foreground (fg:) or background(bg:).\n"   \
   "\n"  \
   "Opacity values are not applied\n"  \
   "to the first plane in a group.\n"   \
   "Consequently, if you have just\n"   \
   "one plane to work with, opacity \n"   \
   "value is meaningless.\n"  \
   "\n"  \
   "Color mixing can be done in two \n"  \
   "ways, use F7 to toggle between \n" \
   "mixing modes.\n"

"Order of Dset's colorplane.\n"  \
   "Dset with highest number is \n"   \
   "on top of the stack. Separate \n"  \
   "stacks exits for foreground (fg:)\n" \
   "and background planes (bg:)."

"If ON, view only the selected\n"\
   "Dset's colors. No mixing of colors in the\n"\
   "foreground stack is done.\n"   \
   "\n"  \
   "If OFF, then mix the color planes\n"  \
   "in the foreground stack.\n"  \
   "\n"  \
   "This option makes it easy to view \n" \
   "one Dset's colors at a time without\n"   \
   "having to worry about color mixing,\n"   \
   "opacity, and stacking order.\n" \
   "\n"  \
   "Needless to say, options such as\n" \
   "'Ord:' and 'Opa:' in this panel are \n" \
   "of little use when this button is ON."

"Toggle Intensity range symmetry\n"   \
   "about 0. \n"   \
   "ON : Intensity clipping range\n"   \
   "     is forced to go from \n"   \
   "     -val to val\n"   \
   "     This allows you to mimic\n"   \
   "     AFNI's ranging mode.\n"   \
   "OFF: Intensity clipping range\n"   \
   "     can be set to your liking."

"Opens a dialog with detailed\n" \
   "information about the surface\n"\
   "object."

"Node index of node in\n"   \
   "focus on this controller's\n"   \
   "surface. Nodes in focus are\n"   \
   "highlighted by the blue sphere\n"   \
   "in the crosshair.\n"   \
   "Entering a new node's index\n"   \
   "will put that node in focus\n"   \
   "and send the crosshair to its\n"   \
   "location (like 'j').\n"   \
   "Use 'alt+l' to center the\n"   \
   "cross hair in your viewer."

"Color from the selected Dset\n" \
   "at the node in focus.\n"   \
   "For the moment, only color\n"   \
   "is displayed. The plan is\n"   \
   "to display labels of various\n"   \
   "sorts here."

"Node index at minimum.\n"   \
   "Right click in cell to\n"   \
   "have crosshair jump to\n"   \
   "node's index.\n"   \
   "Same as 'ctrl+j' or\n"   \
   "an entry in the 'Node' cell\n"   \
   "under Xhair Info block."

"Node index at maximum.\n" \
   "Right click in cell to\n" \
   "have crosshair jump to\n" \
   "node's index.\n"   \
   "Same as 'ctrl+j' or\n"   \
   "an entry in the 'Node' cell\n"   \
   "under Xhair Info block."

"Choose the rendering mode for this surface.\n" \
   "   Viewer: Surface's rendering mode is set\n"  \
   "           by the viewer's setting which can\n"   \
   "           be changed with the 'p' option.\n"  \
   "   Fill:   Shaded rendering mode.\n"  \
   "   Line:   Mesh rendering mode.\n"    \
   "   Points: Points rendering mode."

"Select Brightness (B) column.\n"   \
   "Use this menu to select\n"   \
   "which column in the\n"   \
   "dataset (Dset) should be \n"   \
   "used for color Brightness (B)\n"   \
   "modulation.\n"   \
   "\n"   \
   "B values are the ones used \n"   \
   "to control the brightness of\n"   \
   "a node's color.\n"  \
   "\n"   \
   "Brightness modulation is\n"   \
   "controlled by ranges in the\n"   \
   "'B' cells of the table below.\n"   \
   "\n"   \
   "Brightness modulation is not\n"   \
   "applied when the 'v' button on \n"   \
   "the right is turned off.\n"  \
   "\n"   \
   "B(n) for the selected node n\n"   \
   "is shown in the 'Val'\n"   \
   "table of the 'Xhair Info'\n"   \
   "section on the left."

"Select Intensity (I) column.\n"   \
   "Use this menu to select\n"   \
   "which column in the\n"   \
   "dataset (Dset) should be \n"   \
   "used for an Intensity (I)\n"   \
   "measure.\n"   \
   "\n"   \
   "I values are the ones that \n"   \
   "get colored by the colormap.\n" \
   "\n"   \
   "No coloring is done if the\n"   \
   "'v' button on the right is\n"   \
   "turned off.\n"   \
   "\n"   \
   "I value for the selected node\n"   \
   "is shown in the 'Val' table\n"   \
   "of the 'Xhair Info' section \n"   \
   "on the left."

"Select Threshold (T) column.\n"   \
   "Use this menu to select\n"   \
   "which column in the\n"   \
   "dataset (Dset) should be \n"   \
   "used for a Threshold (T)\n"   \
   "measure.\n"   \
   "\n"   \
   "T values are the ones used \n"   \
   "to determine if a node \n"   \
   "gets colored based on its\n"   \
   "I value.\n"   \
   "\n"   \
   "A node n is not colored if:\n"   \
   "    T(n)   < Tscale   \n"   \
   "or if '|T|' option below\n"   \
   "is turned ON.\n"   \
   "  | T(n) | < Tscale .\n"  \
   "\n"   \
   "Thresholding is not applied\n"   \
   "when the 'v' button on the \n"   \
   "right is turned off.\n"   \
   "\n"   \
   "T(n) for the selected node n\n"   \
   "is shown in the 'Val'\n"   \
   "table of the 'Xhair Info'\n"   \
   "section on the left."

"Minimum clip value.\n" \
   "Clips values (v) in the Dset\n" \
   "less than Minimum (min):\n"  \
   "  if v < min then v = min "

"Maximum clip value.\n" \
   "Clips values (v) in the Dset\n" \
   "larger than Maximum (max):\n"  \
   "  if v > max then v = max "

"Used for setting the clipping ranges."   \
   "Clipping is only done for \n"   \
   "color mapping. Actual data \n"   \
   "values do not change."

"Intensity clipping range.\n" \
   "Values in the intensity data \n"   \
   "that are less than Min are colored\n"   \
   "by the first (bottom) color of the \n"   \
   "colormap. \n"   \
   "Values larger than Max are mapped \n"   \
   "to the top color.\n"   \
   "\n"   \
   "Left click locks ranges\n"   \
   "from automatic resetting.\n"   \
   "Locked range is applied to\n"   \
   "current Dset only.\n"   \
   "\n"   \
   "Right click resets values\n"   \
   "to full range in data."

"Brightness modulation clipping range.\n"   \
   "Values in the brightness data are\n"   \
   "clipped to the Min to Max range before\n"   \
   "calculating their modulation factor\n"   \
   "(see next table row).\n"   \
   "\n"   \
   "Left click locks ranges\n"   \
   "from automatic resetting.\n"   \
   "Locked range is applied to\n"   \
   "current Dset only.\n"  \
   "\n"   \
   "Right click resets values\n"   \
   "to full range in data."

"Brightness modulation factor range.\n"   \
   "Brightness modulation values, after\n"   \
   "clipping per the values in the row above,\n"   \
   "are scaled to fit the range specified\n"   \
   "here."

"Coordinate bias range.\n"   \
   "Coordinates of nodes that are mapped\n"   \
   "to the colormap can have a bias added\n"   \
   "to their coordinates. \n"   \
   "\n"   \
   "Nodes mapped to the first color of \n"   \
   "the map receive the minimum bias and\n"   \
   "nodes mapped to the last color receive\n"   \
   "the maximum bias. \n"   \
   "\n"   \
   "Nodes not colored, because of \n"   \
   "thresholding for example, will \n"   \
   "have no bias applied."

"Toggle color masking of nodes \n"   \
   "with intensity = 0 \n"   \
   "ON : 0 intensities are mapped\n"   \
   "     to the colormap as any\n"   \
   "     other values.\n"   \
   "OFF: 0 intensities are masked,\n"   \
   "     a la AFNI"

"1- Triangle (faceset) index of\n"   \
   "triangle in focus on this \n"   \
   "on this controller's surface.\n"   \
   "Triangle in focus is highlighted\n"   \
   "in gray. Entering a new triangle's\n"   \
   "index will set a new triangle in\n"   \
   "focus (like 'J').\n"   \
   "2- Nodes forming triangle."

"Crosshair coordinates on\n"   \
   "this controller's surface.\n"   \
   "Entering new coordinates \n"   \
   "makes the crosshair jump\n"   \
   "to that location (like 'ctrl+j').\n"   \
   "Use 'alt+l' to center the\n"   \
   "cross hair in your viewer."

{  \
   int m_nmx, m_i=0; \
   m_nmx = TF->Ni*TF->Nj;  \
   Found = -1; \
   while (m_i<m_nmx) {  \
      if (TF->cells[m_i] == w) { Found = m_i; m_i = m_nmx; }      \
      ++m_i;   \
   }  \
}

{\
    \
    \
   sprintf(str,"%s", MV_format_fval2(v[0], 7)); \
   sprintf(str,"%s, %s", str, MV_format_fval2(v[1], 7)); \
   sprintf(str,"%s, %s", str, MV_format_fval2(v[2], 7)); \
}

01347 {
01348    static char FuncName[]={"SUMA_AllocTableField"};
01349    SUMA_TABLE_FIELD *TF = NULL;
01350 
01351    SUMA_ENTRY;
01352    TF = (SUMA_TABLE_FIELD *)SUMA_malloc(sizeof(SUMA_TABLE_FIELD));
01353    if (!TF) {
01354       SUMA_SL_Crit("Failed to allocate");
01355       SUMA_RETURN(TF);
01356    }
01357    TF->Ni = -1;
01358    TF->Nj = -1;
01359    TF->rc = NULL;
01360    TF->cells = NULL;
01361    TF->cwidth = NULL;
01362    TF->editable = NOPE;
01363    TF->type = SUMA_string;
01364    TF->NewValueCallback = NULL;
01365    TF->NewValueCallbackData = NULL;
01366    TF->TitLabelEVHandler = NULL;
01367    TF->TitLabelEVHandlerData = NULL;
01368    TF->CellEVHandler = NULL;
01369    TF->CellEVHandlerData = NULL;
01370    TF->cell_modified = -1;
01371    TF->num_value = NULL;
01372    TF->str_value = NULL;
01373    SUMA_RETURN(TF);
01374 }

00969 {
00970    static char FuncName[]={"SUMA_cb_AbsThresh_tb_toggled"};
00971    SUMA_SurfaceObject *SO = NULL;
00972    char slabel[100];
00973    float range[2]; int loc[2];  
00974    SUMA_Boolean LocalHead = NOPE;
00975    
00976    SUMA_ENTRY;
00977    
00978    SUMA_LH("Called");
00979    
00980    SO = (SUMA_SurfaceObject *)data;
00981    
00982    if (!SO->SurfCont->curColPlane) SUMA_RETURNe;
00983 
00984    if (SO->SurfCont->curColPlane->OptScl->ThrMode != SUMA_ABS_LESS_THAN) {
00985       SO->SurfCont->curColPlane->OptScl->ThrMode = SUMA_ABS_LESS_THAN;
00986       /* used to use this:
00987       sprintf(slabel, "|%5s|", .... 
00988       but that does not work in the editable field ... */
00989       sprintf(slabel, "%5s", MV_format_fval(fabs(SO->SurfCont->curColPlane->OptScl->ThreshRange[0])));
00990    } else {
00991       SO->SurfCont->curColPlane->OptScl->ThrMode = SUMA_LESS_THAN;
00992       sprintf(slabel, "%5s", MV_format_fval(SO->SurfCont->curColPlane->OptScl->ThreshRange[0]));
00993    }
00994    /* SUMA_SET_LABEL(SO->SurfCont->thr_lb,  slabel); */
00995    SUMA_INSERT_CELL_STRING(SO->SurfCont->SetThrScaleTable, 0,0,slabel); 
00996    if (SUMA_GetDsetColRange(SO->SurfCont->curColPlane->dset_link, SO->SurfCont->curColPlane->OptScl->tind, range, loc)) {   
00997       SUMA_SetScaleRange(SO, range );
00998    }else {
00999       SUMA_SLP_Err("Failed to get range");
01000       SUMA_RETURNe;
01001    }
01002       
01003    if (!SO->SurfCont->curColPlane->OptScl->UseThr) { SUMA_RETURNe; } /* nothing else to do */
01004 
01005    if (!SUMA_ColorizePlane (SO->SurfCont->curColPlane)) {
01006          SUMA_SLP_Err("Failed to colorize plane.\n");
01007          SUMA_RETURNe;
01008    }
01009    
01010    SUMA_RemixRedisplay(SO);
01011 
01012    SUMA_UpdateNodeLblField(SO);
01013 
01014    SUMA_RETURNe;
01015 }

03558 {
03559    static char FuncName[]={"SUMA_cb_CloseSwitchCmap"};
03560    SUMA_LIST_WIDGET *LW = NULL;
03561    SUMA_Boolean LocalHead = NOPE;
03562    
03563    SUMA_ENTRY;
03564    
03565    SUMA_LH("Called");
03566    
03567    LW = (SUMA_LIST_WIDGET *)client_data;
03568    
03569    #if defined SUMA_USE_WITHDRAW 
03570       if (LocalHead) fprintf (SUMA_STDERR,"%s: Withdrawing list widget %s...\n", FuncName, LW->Label);
03571       
03572       XWithdrawWindow(SUMAg_CF->X->DPY_controller1, 
03573          XtWindow(LW->toplevel),
03574          XScreenNumberOfScreen(XtScreen(LW->toplevel)));
03575    #elif defined SUMA_USE_DESTROY 
03576          if (LocalHead) fprintf (SUMA_STDERR,"%s: Destroying list widget %s...\n", FuncName, LW->Label);
03577          XtDestroyWidget(LW->toplevel);
03578          LW->toplevel = NULL;
03579    #endif
03580    
03581    LW->isShaded = YUP; 
03582    
03583    
03584    
03585    SUMA_RETURNe;
03586 }

04481 {
04482    static char FuncName[]={"SUMA_cb_Cmap_Load"};
04483    SUMA_LIST_WIDGET *LW=NULL;
04484    SUMA_SurfaceObject *SO=NULL;
04485    DList *list = NULL;
04486    SUMA_EngineData *ED = NULL;
04487    DListElmt *NextElm = NULL;
04488    SUMA_Boolean LocalHead = NOPE;
04489     
04490    SUMA_ENTRY;
04491    
04492    SUMA_LH("Called");
04493    
04494    SO = (SUMA_SurfaceObject *)data;
04495    
04496    if (!list) list = SUMA_CreateList();
04497    ED = SUMA_InitializeEngineListData (SE_OpenCmapFileSelection);
04498    if (!(NextElm = SUMA_RegisterEngineListCommand (  list, ED,
04499                                           SEF_vp, (void *)SO,
04500                                           SES_Suma, NULL, NOPE,
04501                                           SEI_Head, NULL))) {
04502       fprintf (SUMA_STDERR, "Error %s: Failed to register command.\n", FuncName);
04503    }
04504    SUMA_RegisterEngineListCommand (  list, ED,
04505                                      SEF_ip, (void *)SO->SurfCont->TopLevelShell,
04506                                      SES_Suma, NULL, NOPE,
04507                                      SEI_In, NextElm);
04508    if (!SUMA_Engine (&list)) {
04509       fprintf(SUMA_STDERR, "Error %s: SUMA_Engine call failed.\n", FuncName);
04510    }
04511    
04512    SUMA_RETURNe;
04513 }

03441 {
03442    static char FuncName[]={"SUMA_cb_SelectSwitchCmap"};
03443    SUMA_SurfaceObject *SO = NULL;
03444    SUMA_MenuCallBackData data;
03445    SUMA_LIST_WIDGET *LW = NULL;
03446    SUMA_Boolean CloseShop = NOPE, Found = NOPE;
03447    XmListCallbackStruct *cbs = (XmListCallbackStruct *) call_data;
03448    char *choice=NULL;
03449    int ichoice = -1;
03450    SUMA_COLOR_MAP *CM = NULL;
03451    SUMA_Boolean LocalHead = NOPE;
03452    
03453    SUMA_ENTRY;
03454    
03455    SUMA_LH("Called");
03456    SO = (SUMA_SurfaceObject *)client_data;
03457    LW = SUMAg_CF->X->SwitchCmapLst;
03458    
03459    if (!LW) {
03460       SUMA_S_Err("NULL LW!");
03461       SUMA_RETURNe;
03462    }
03463    
03464    
03465    if (cbs->reason == XmCR_SINGLE_SELECT) {
03466       if (LocalHead) fprintf (SUMA_STDERR,"%s: Single selection, list widget %s... \n", FuncName, LW->Label);
03467    } else {
03468       if (LocalHead) fprintf (SUMA_STDERR,"%s: Default selection, list widget %s... \n", FuncName, LW->Label);
03469       /*double click or enter on that one, close shop after selection */
03470       CloseShop = YUP;
03471    }
03472    
03473    XmStringGetLtoR (cbs->item, XmFONTLIST_DEFAULT_TAG, &choice);
03474    
03475    if (LocalHead) fprintf (SUMA_STDERR,"%s: Selected item: %s {%s} (%d)\n", FuncName, choice, choice, cbs->item_position);
03476    /* because of sorting, choice cannot be used as an index into clist and oplist in ALS */
03477    Found = NOPE;
03478    ichoice = 0;
03479    do {
03480       if (LocalHead) fprintf (SUMA_STDERR,"%s: Comparing:\n%s\n%s\n", FuncName, LW->ALS->clist[ichoice], choice);
03481       if (strncmp(LW->ALS->clist[ichoice], choice, strlen(choice)) == 0) Found = YUP; 
03482       else ++ichoice;
03483    } while (ichoice < LW->ALS->N_clist && !Found);
03484    
03485    if (!Found) {
03486       SUMA_SLP_Err("Choice not found.");
03487       SUMA_RETURNe;
03488    }
03489    
03490    XtFree (choice);
03491    
03492    /* now retrieve that choice from the SUMA_ASSEMBLE_LIST_STRUCT structure and initialize the drawing window */
03493    if (LW->ALS) {
03494       if (LocalHead) fprintf (SUMA_STDERR,"%s: N_clist = %d\n", FuncName, LW->ALS->N_clist); 
03495       if (LW->ALS->N_clist > ichoice) {
03496          CM = (SUMA_COLOR_MAP *)LW->ALS->oplist[ichoice];
03497          if (LocalHead) fprintf (SUMA_STDERR,"%s: Retrieved Colmap named %s\n", FuncName, CM->Name);
03498          /* Now you need to set the button menu to reflect the choice made */
03499          if (!SUMA_SetCmapMenuChoice (SO, LW->ALS->clist[ichoice])) {
03500             SUMA_SL_Err("Failed in SUMA_SetCmapMenuChoice");
03501          }
03502          if (!SUMA_SwitchColPlaneCmap(SO, CM)) {
03503             SUMA_SL_Err("Failed in SUMA_SwitchColPlaneCmap");
03504          }
03505       }
03506    } else {
03507       if (LocalHead) fprintf (SUMA_STDERR,"%s: NULL ALS\n", FuncName); 
03508    }
03509 
03510    if (CloseShop) {
03511       SUMA_cb_CloseSwitchCmap( w,  (XtPointer)LW,  call_data);
03512    }  
03513    
03514    /* update Lbl fields */
03515    SUMA_UpdateNodeLblField(SO);
03516 
03517    SUMA_RETURNe;
03518 }

00626 {
00627    static char FuncName[]={"SUMA_cb_set_threshold_label"};
00628    SUMA_SurfaceObject *SO=NULL;
00629    XmScaleCallbackStruct * cbs = (XmScaleCallbackStruct *) call ;
00630    float fff ;
00631    int dec;
00632    char slabel[100];
00633    SUMA_Boolean LocalHead = NOPE;
00634 
00635    SUMA_ENTRY;
00636    
00637    SUMA_LH("called");
00638    SO = (SUMA_SurfaceObject *)clientData;
00639    if (!SO) { SUMA_SL_Err("NULL SO"); SUMA_RETURNe; }
00640    
00641    XtVaGetValues(w, XmNuserData, &dec, NULL);
00642    if (SO->SurfCont->curColPlane->OptScl->ThrMode != SUMA_ABS_LESS_THAN) 
00643       sprintf(slabel, "%5s", MV_format_fval((float)cbs->value / pow(10.0, dec))); 
00644    else {
00645       /* used to use this:
00646       sprintf(slabel, "|%5s|", .... 
00647       but that does not work in the editable field ... */
00648       sprintf(slabel, "%5s", MV_format_fval((float)cbs->value / pow(10.0, dec))); 
00649    }
00650    /* SUMA_SET_LABEL(SO->SurfCont->thr_lb,  slabel);*/
00651       SUMA_INSERT_CELL_STRING(SO->SurfCont->SetThrScaleTable, 0,0,slabel); 
00652 
00653    
00654    /* You must use the line below if you are calling this function on the fly */
00655    /* SUMA_FORCE_SCALE_HEIGHT(SO);  */
00656    
00657    #if SUMA_SEPARATE_SURF_CONTROLLERS
00658       SUMA_UpdateColPlaneShellAsNeeded(SO);
00659    #endif
00660    
00661    SUMA_RETURNe;
00662 }

01168 {
01169    static char FuncName[]={"SUMA_cb_SetCmapMode"};
01170    SUMA_MenuCallBackData *datap=NULL;
01171    int imenu;
01172    SUMA_SurfaceObject *SO = NULL;
01173    SUMA_Boolean NewDisp = NOPE;
01174    SUMA_Boolean LocalHead = NOPE;
01175    
01176    SUMA_ENTRY;
01177    
01178    /* get the surface object that the setting belongs to */
01179    datap = (SUMA_MenuCallBackData *)client_data;
01180    SO = (SUMA_SurfaceObject *)datap->ContID;
01181    imenu = (int)datap->callback_data; 
01182    NewDisp = NOPE;
01183    switch (imenu) {
01184       case SW_Interp:
01185          if (SO->SurfCont->curColPlane->OptScl->interpmode != SUMA_INTERP) {
01186             SO->SurfCont->curColPlane->OptScl->interpmode = SUMA_INTERP;
01187             NewDisp = YUP;
01188          }
01189          break;
01190       case SW_NN:
01191          if (SO->SurfCont->curColPlane->OptScl->interpmode != SUMA_NO_INTERP) {
01192             SO->SurfCont->curColPlane->OptScl->interpmode = SUMA_NO_INTERP;
01193             NewDisp = YUP;
01194          }
01195          break;
01196       case SW_Direct:
01197          if (SO->SurfCont->curColPlane->OptScl->interpmode != SUMA_DIRECT) {
01198             SO->SurfCont->curColPlane->OptScl->interpmode = SUMA_DIRECT;
01199             NewDisp = YUP;
01200          }
01201          break;
01202       default: 
01203          fprintf (SUMA_STDERR, "Error %s: Unexpected widget index.\n", FuncName);
01204          break;
01205    }
01206    
01207    /* redisplay all viewers showing SO*/
01208    if (NewDisp) {
01209       SUMA_ColorizePlane(SO->SurfCont->curColPlane);
01210       SUMA_RemixRedisplay(SO);
01211    }
01212    
01213    SUMA_UpdateNodeNodeField(SO);
01214    SUMA_UpdateNodeLblField(SO);
01215    
01216    SUMA_RETURNe;
01217 }

01225 {
01226    static char FuncName[]={"SUMA_cb_SetCoordBias"};
01227    SUMA_MenuCallBackData *datap=NULL;
01228    int imenu;
01229    SUMA_SurfaceObject *SO = NULL;
01230    SUMA_Boolean NewDisp = NOPE;
01231    SUMA_Boolean LocalHead = NOPE;
01232    
01233    SUMA_ENTRY;
01234    
01235    /* get the surface object that the setting belongs to */
01236    datap = (SUMA_MenuCallBackData *)client_data;
01237    SO = (SUMA_SurfaceObject *)datap->ContID;
01238    imenu = (int)datap->callback_data; 
01239    NewDisp = NOPE;
01240    switch (imenu) {
01241       case SW_CoordBias_None:
01242          if (SO->SurfCont->curColPlane->OptScl->DoBias != SW_CoordBias_None) {
01243             if (SO->SurfCont->curColPlane->OptScl->BiasVect) {
01244                SUMA_RemoveCoordBias(SO->SurfCont->curColPlane);
01245             }
01246             NewDisp = YUP;
01247          }
01248          break;
01249       case SW_CoordBias_X:
01250          if (SO->SurfCont->curColPlane->OptScl->DoBias != SW_CoordBias_X) { /* something needs to be done */
01251                /* bias other than on other dimension exists, transfer it to new dimension*/
01252                SUMA_TransferCoordBias(SO->SurfCont->curColPlane, SW_CoordBias_X);
01253             NewDisp = YUP;
01254          }
01255          break;
01256       case SW_CoordBias_Y:
01257          if (SO->SurfCont->curColPlane->OptScl->DoBias != SW_CoordBias_Y) { /* something needs to be done */
01258                /* bias other than on other dimension exists, transfer it to new dimension*/
01259                SUMA_TransferCoordBias(SO->SurfCont->curColPlane, SW_CoordBias_Y);
01260             NewDisp = YUP;
01261          }
01262          break;
01263       case SW_CoordBias_Z:
01264          if (SO->SurfCont->curColPlane->OptScl->DoBias != SW_CoordBias_Z) { /* something needs to be done */
01265                /* bias other than on other dimension exists, transfer it to new dimension*/
01266                SUMA_TransferCoordBias(SO->SurfCont->curColPlane, SW_CoordBias_Z);
01267             NewDisp = YUP;
01268          }
01269          break;
01270       case SW_CoordBias_N:
01271          if (SO->SurfCont->curColPlane->OptScl->DoBias != SW_CoordBias_N) { /* something needs to be done */
01272                /* bias other than on other dimension exists, transfer it to new dimension*/
01273                SUMA_TransferCoordBias(SO->SurfCont->curColPlane, SW_CoordBias_N);
01274             NewDisp = YUP;
01275          }
01276          break;
01277       default: 
01278          fprintf (SUMA_STDERR, "Error %s: Unexpected widget index.\n", FuncName);
01279          break;
01280    }
01281    
01282    /* redisplay all viewers showing SO*/
01283    if (NewDisp) {
01284       SUMA_ColorizePlane(SO->SurfCont->curColPlane);
01285       SUMA_RemixRedisplay(SO);
01286    }
01287    
01288    SUMA_UpdateNodeNodeField(SO);
01289    
01290    #if SUMA_SEPARATE_SURF_CONTROLLERS
01291       SUMA_UpdateColPlaneShellAsNeeded(SO);
01292    #endif
01293    SUMA_RETURNe;
01294 }

00893 {
00894    static char FuncName[]={"SUMA_cb_SymIrange_tb_toggled"};
00895    SUMA_SurfaceObject *SO = NULL;
00896    SUMA_TABLE_FIELD *TF=NULL;
00897    SUMA_Boolean LocalHead = NOPE;
00898    
00899    SUMA_ENTRY;
00900    
00901    SUMA_LH("Called");
00902    
00903    SO = (SUMA_SurfaceObject *)data;
00904    
00905    if (!SO->SurfCont->curColPlane) SUMA_RETURNe;
00906    
00907    SO->SurfCont->curColPlane->OptScl->MaskZero = !SO->SurfCont->curColPlane->OptScl->MaskZero;
00908    
00909    if (!SO->SurfCont->curColPlane->Show) { SUMA_RETURNe; } /* nothing else to do */
00910    
00911    if (!SUMA_ColorizePlane (SO->SurfCont->curColPlane)) {
00912          SUMA_SLP_Err("Failed to colorize plane.\n");
00913          SUMA_RETURNe;
00914    }
00915    
00916    SUMA_RemixRedisplay(SO);
00917  
00918    SUMA_UpdateNodeLblField(SO);
00919    
00920 
00921 }

00807 {
00808    static char FuncName[]={"SUMA_cb_SwitchBrightness"};
00809    int imenu = 0;
00810    SUMA_MenuCallBackData *datap=NULL;
00811    SUMA_SurfaceObject *SO = NULL;
00812    SUMA_Boolean LocalHead = NOPE;
00813    
00814    SUMA_ENTRY;
00815    
00816    /* get the surface object that the setting belongs to */
00817    datap = (SUMA_MenuCallBackData *)client_data;
00818    SO = (SUMA_SurfaceObject *)datap->ContID;
00819    imenu = (int)datap->callback_data; 
00820    
00821    if (LocalHead) {
00822       fprintf(SUMA_STDERR, "%s:\n request to switch brightness to col. %d\n", FuncName, imenu - 1);
00823    }
00824    
00825    SO->SurfCont->curColPlane->OptScl->bind = imenu - 1;
00826 
00827    SUMA_InitRangeTable(SO, 1) ;
00828 
00829    SUMA_UpdateNodeValField(SO);
00830    if (!SO->SurfCont->curColPlane->OptScl->UseBrt) { SUMA_RETURNe; } /* nothing else to do */
00831    
00832    if (!SUMA_ColorizePlane (SO->SurfCont->curColPlane)) {
00833          SUMA_SLP_Err("Failed to colorize plane.\n");
00834          SUMA_RETURNe;
00835    }
00836    
00837 
00838    SUMA_RemixRedisplay(SO);
00839    
00840    #if SUMA_SEPARATE_SURF_CONTROLLERS
00841       SUMA_UpdateColPlaneShellAsNeeded(SO);
00842    #endif
00843    
00844    SUMA_UpdateNodeLblField(SO);
00845 
00846    SUMA_RETURNe;
00847 }

00853 {
00854    static char FuncName[]={"SUMA_cb_SwitchCmap"};
00855    SUMA_MenuCallBackData *datap=NULL;
00856    SUMA_SurfaceObject *SO = NULL;
00857    SUMA_COLOR_MAP *CM = NULL;
00858    SUMA_Boolean LocalHead = NOPE;
00859    
00860    SUMA_ENTRY;
00861    
00862    /* get the surface object that the setting belongs to */
00863    datap = (SUMA_MenuCallBackData *)client_data;
00864    SO = (SUMA_SurfaceObject *)datap->ContID;
00865    CM = (SUMA_COLOR_MAP *)datap->callback_data; 
00866    
00867    if (LocalHead) {
00868       fprintf(SUMA_STDERR, "%s:\n request to switch colormap to  (%s)\n", 
00869          FuncName, CM->Name);
00870    }
00871    
00872    if (!SUMA_SwitchColPlaneCmap(SO, CM)) {
00873       SUMA_SL_Err("Failed in SUMA_SwitchColPlaneCmap");
00874    }
00875    
00876    /* Now you'll need to close the list widget if a choice has been made */
00877    if (SUMAg_CF->X->SwitchCmapLst) {
00878       if (!SUMAg_CF->X->SwitchCmapLst->isShaded) 
00879          SUMA_cb_CloseSwitchCmap( w,  (XtPointer)SUMAg_CF->X->SwitchCmapLst,  call);
00880    }
00881    
00882    #if SUMA_SEPARATE_SURF_CONTROLLERS
00883       SUMA_UpdateColPlaneShellAsNeeded(SO);
00884    #endif
00885    
00886    /* update Lbl fields */
00887    SUMA_UpdateNodeLblField(SO);
00888 
00889    SUMA_RETURNe;
00890 }

00707 {
00708    static char FuncName[]={"SUMA_cb_SwitchIntensity"};
00709    int imenu = 0;
00710    char srange[500];
00711    SUMA_MenuCallBackData *datap=NULL;
00712    SUMA_SurfaceObject *SO = NULL;
00713    SUMA_Boolean LocalHead = NOPE;
00714    
00715    SUMA_ENTRY;
00716    
00717    /* get the surface object that the setting belongs to */
00718    datap = (SUMA_MenuCallBackData *)client_data;
00719    SO = (SUMA_SurfaceObject *)datap->ContID;
00720    imenu = (int)datap->callback_data; 
00721    
00722    if (!SO->SurfCont->curColPlane) { SUMA_RETURNe; }
00723    if (LocalHead) {
00724       fprintf(SUMA_STDERR, "%s:\n request to switch intensity to col. %d\n", FuncName, imenu - 1);
00725       fprintf(SUMA_STDERR, "SO->Label = %s\n", SO->Label);
00726    }
00727    
00728    SO->SurfCont->curColPlane->OptScl->find = imenu - 1;
00729 
00730    SUMA_InitRangeTable(SO, 0) ;
00731 
00732    if (!SO->SurfCont->curColPlane->Show) { SUMA_RETURNe; } /* nothing else to do */
00733    
00734    
00735    if (!SUMA_ColorizePlane (SO->SurfCont->curColPlane)) {
00736          SUMA_SLP_Err("Failed to colorize plane.\n");
00737          SUMA_RETURNe;
00738    }
00739    
00740    
00741    SUMA_RemixRedisplay(SO);
00742 
00743    #if SUMA_SEPARATE_SURF_CONTROLLERS
00744       SUMA_UpdateColPlaneShellAsNeeded(SO);
00745    #endif
00746  
00747    SUMA_UpdateNodeValField(SO);
00748    SUMA_UpdateNodeLblField(SO);
00749 
00750    SUMA_RETURNe;
00751 }

00754 {
00755    static char FuncName[]={"SUMA_cb_SwitchThreshold"};
00756    int imenu = 0;
00757    char srange[500];
00758    SUMA_MenuCallBackData *datap=NULL;
00759    SUMA_SurfaceObject *SO = NULL;
00760    float range[2]; int loc[2];  
00761    SUMA_Boolean LocalHead = NOPE;
00762    
00763    SUMA_ENTRY;
00764    
00765    /* get the surface object that the setting belongs to */
00766    datap = (SUMA_MenuCallBackData *)client_data;
00767    SO = (SUMA_SurfaceObject *)datap->ContID;
00768    imenu = (int)datap->callback_data; 
00769    
00770    if (!SO->SurfCont->curColPlane) { SUMA_RETURNe; }
00771    
00772    if (LocalHead) {
00773       fprintf(SUMA_STDERR, "%s:\n request to switch threshold to col. %d\n", FuncName, imenu -1);
00774    }
00775    SO->SurfCont->curColPlane->OptScl->tind = imenu - 1;
00776    
00777    if (SUMA_GetDsetColRange(SO->SurfCont->curColPlane->dset_link, SO->SurfCont->curColPlane->OptScl->tind, range, loc)) {   
00778       SUMA_SetScaleRange(SO, range );
00779    }else {
00780       SUMA_SLP_Err("Failed to get range");
00781       SUMA_RETURNe;
00782    }
00783     
00784    SUMA_InitRangeTable(SO, -1) ;
00785    
00786    SUMA_UpdateNodeValField(SO);
00787    
00788    if (!SO->SurfCont->curColPlane->OptScl->UseThr) { SUMA_RETURNe; } /* nothing else to do */
00789 
00790    if (!SUMA_ColorizePlane (SO->SurfCont->curColPlane)) {
00791          SUMA_SLP_Err("Failed to colorize plane.\n");
00792          SUMA_RETURNe;
00793    }
00794    
00795    SUMA_RemixRedisplay(SO);
00796 
00797    #if SUMA_SEPARATE_SURF_CONTROLLERS
00798       SUMA_UpdateColPlaneShellAsNeeded(SO);
00799    #endif
00800    
00801    SUMA_UpdateNodeLblField(SO);
00802    
00803    SUMA_RETURNe;
00804 }

00925 {
00926    static char FuncName[]={"SUMA_cb_SymIrange_tb_toggled"};
00927    SUMA_SurfaceObject *SO = NULL;
00928    SUMA_TABLE_FIELD *TF=NULL;
00929    SUMA_Boolean LocalHead = NOPE;
00930    
00931    SUMA_ENTRY;
00932    
00933    SUMA_LH("Called");
00934    
00935    SO = (SUMA_SurfaceObject *)data;
00936    
00937    if (!SO->SurfCont->curColPlane) SUMA_RETURNe;
00938    
00939    SO->SurfCont->curColPlane->SymIrange = !SO->SurfCont->curColPlane->SymIrange;
00940    
00941    if (SO->SurfCont->curColPlane->SymIrange) {
00942       /* manual setting of range. DO NOT Call SUMA_InitRangeTable because it will automatically update the I range under certain conditions*/
00943       TF = SO->SurfCont->SetRangeTable;
00944       SO->SurfCont->curColPlane->OptScl->IntRange[1] = 
00945          SUMA_LARG_ABS(SO->SurfCont->curColPlane->OptScl->IntRange[0], SO->SurfCont->curColPlane->OptScl->IntRange[1]);
00946       SO->SurfCont->curColPlane->OptScl->IntRange[0] = -SO->SurfCont->curColPlane->OptScl->IntRange[1];
00947       SUMA_INSERT_CELL_VALUE(TF, 1, 1, SO->SurfCont->curColPlane->OptScl->IntRange[0]);
00948       SUMA_INSERT_CELL_VALUE(TF, 1, 2, SO->SurfCont->curColPlane->OptScl->IntRange[1]);
00949    }
00950    
00951    if (!SO->SurfCont->curColPlane->Show) { SUMA_RETURNe; } /* nothing else to do */
00952    
00953    
00954    if (!SUMA_ColorizePlane (SO->SurfCont->curColPlane)) {
00955          SUMA_SLP_Err("Failed to colorize plane.\n");
00956          SUMA_RETURNe;
00957    }
00958    
00959    SUMA_RemixRedisplay(SO);
00960  
00961    SUMA_UpdateNodeValField(SO);
00962    SUMA_UpdateNodeLblField(SO);
00963    
00964 
00965    SUMA_RETURNe;
00966 }

01923 {
01924    static char FuncName[]={"SUMA_cellvariety"};
01925    int i, j;
01926    SUMA_Boolean LocalHead = NOPE;
01927    
01928    SUMA_ENTRY;
01929    
01930    if (!TF) SUMA_RETURN(SUMA_ERROR_CELL);
01931    i = n % TF->Ni;
01932    j = n / TF->Ni;
01933    if (TF->HasColTit && i == 0) SUMA_RETURN(SUMA_COL_TIT_CELL);
01934    if (TF->HasRowTit && j == 0) SUMA_RETURN(SUMA_ROW_TIT_CELL);
01935    SUMA_RETURN(SUMA_ENTRY_CELL);
01936 }

00124 {
00125    static char FuncName[]={"SUMA_cmap_context_Init"};
00126    GLfloat mat_specular[] = { 0.0, 0.0, 0.0, 1.0};
00127    GLfloat mat_shininess[] = { 0 };
00128    GLfloat mat_ambient[] = { 0.0, 0.0, 0.0, 1.0};
00129    GLfloat mat_diffuse[] = { 1.0, 1.0, 1.0, 1.0 };
00130    GLfloat mat_emission[] = { SUMA_MAT_EMISSION_INIT  };
00131    GLfloat clear_color[] = { 0.0, 0.0, 0.0, 0.0};
00132    GLfloat light0_color[] = { 1.0, 1.0, 1.0, 1.0};
00133    GLfloat lmodel_ambient[] = {1.0, 1.0, 1.0, 1.0};
00134    GLfloat light0_position[] = {0.0, 0.0, -1.0, 0.0};
00135    GLfloat ViewFrom[]={0.0, 0.0, 300};
00136    GLfloat ViewCenter[]={0.0, 0.0, 0.0};
00137    GLfloat ViewCamUp[]={0.0, 1.0, 0.0};
00138    GLfloat CmapOrig[]={SUMA_CMAP_ORIGIN};
00139    GLfloat CmapTL[]={SUMA_CMAP_TOPLEFT};
00140    int i;
00141    
00142    SUMA_ENTRY;
00143 
00144    glClearColor (clear_color[0], clear_color[1], clear_color[2], clear_color[3]);
00145    glShadeModel (GL_SMOOTH);
00146 
00147    SUMA_SET_GL_RENDER_MODE(SRM_Fill); 
00148    
00149       
00150    /* Set the material properties*/
00151    glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
00152    glMaterialfv(GL_FRONT, GL_AMBIENT, mat_ambient);
00153    glMaterialfv(GL_FRONT, GL_DIFFUSE, mat_diffuse);
00154    glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
00155    glMaterialfv(GL_FRONT, GL_EMISSION, mat_emission);
00156     
00157    /* set the directional light properties */
00158    glLightfv(GL_LIGHT0, GL_POSITION, light0_position);
00159    glLightfv(GL_LIGHT0, GL_DIFFUSE, light0_color);
00160    glLightfv(GL_LIGHT0, GL_SPECULAR, light0_color);
00161 
00162    /* set the ambient light */
00163    glLightModelfv(GL_LIGHT_MODEL_AMBIENT, lmodel_ambient);
00164  
00165    glEnable(GL_LIGHTING); /* prepare GL to perform lighting calculations */
00166    glEnable(GL_LIGHT0); /*Turn lights ON */
00167    glEnable(GL_DEPTH_TEST);
00168    
00169    /*setup the view point and then setup the lights. Those lights will remain in place regardless of the rotations/translations
00170    done on the surface */
00171    for (i=0; i<2; ++i) { ViewCenter[i] = (CmapTL[i] - CmapOrig[i]) / 2.0;  }
00172    ViewFrom[0] = ViewCenter[0]; ViewFrom[1] = ViewCenter[1]; ViewFrom[2] = SUMA_CMAP_VIEW_FROM;
00173     
00174    glMatrixMode(GL_MODELVIEW);
00175    glLoadIdentity();
00176    gluLookAt ( ViewFrom[0], ViewFrom[1], ViewFrom[2],  
00177                ViewCenter[0], ViewCenter[1], ViewCenter[2],
00178                ViewCamUp[0], ViewCamUp[1], ViewCamUp[2] );
00179    
00180    
00181    SUMA_RETURNe;
00182    
00183 }

00237 {   
00238    static char FuncName[]={"SUMA_cmap_wid_display"};
00239    int i;
00240    GLfloat rotationMatrix[4][4];
00241    float currentQuat[]={0.0, 0.0, 0.0, 1.0};
00242    GLfloat clear_color[] = { 0.8, 0.8, 0.8, 0.0};
00243    GLfloat RotaCenter[]={0.0, 0.0, 0.0};
00244    SUMA_COLOR_MAP *Cmap = NULL;
00245    SUMA_Boolean LocalHead = NOPE; /* local headline debugging messages */   
00246     
00247    SUMA_ENTRY;
00248    
00249    SUMA_LH("in, lots of inefficiencies here, make sure you revisit");
00250    
00251    /* now you need to set the clear_color since it can be changed per viewer Thu Dec 12 2002 */
00252    glClearColor (clear_color[0], clear_color[1],clear_color[2],clear_color[3]);
00253       
00254    if (LocalHead) fprintf (SUMA_STDOUT,"%s: Building Rotation matrix ...\n", FuncName);
00255    SUMA_build_rotmatrix(rotationMatrix, currentQuat);
00256     
00257    if (LocalHead) fprintf (SUMA_STDOUT,"%s: performing glClear ...\n", FuncName);
00258    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* clear the Color Buffer and the depth buffer */
00259    
00260    /* careful here, you might want to turn the next block into a macro like SUMA_SET_GL_PROJECTION */
00261    if (LocalHead) fprintf (SUMA_STDOUT,"%s: Setting up matrix mode and perspective ...\nFOV=%f\n", FuncName, SUMA_CMAP_FOV_INITIAL);
00262    glMatrixMode (GL_PROJECTION);
00263    glLoadIdentity ();
00264    gluPerspective(SO->SurfCont->cmp_ren->FOV, (double)SUMA_CMAP_WIDTH/SUMA_CMAP_HEIGHT, SUMA_PERSPECTIVE_NEAR, SUMA_PERSPECTIVE_FAR); /*lower angle is larger zoom,*/
00265 
00266    glMatrixMode(GL_MODELVIEW);
00267    glPushMatrix();
00268    glTranslatef (SO->SurfCont->cmp_ren->translateVec[0], SO->SurfCont->cmp_ren->translateVec[1], SO->SurfCont->cmp_ren->translateVec[2] );
00269    if (0){
00270    SUMA_SL_Note("no need for shananigans\n"
00271                   "But to illustrate ...\n");
00272    glTranslatef (RotaCenter[0], RotaCenter[1], RotaCenter[2]);
00273    glMultMatrixf(&rotationMatrix[0][0]);
00274    glTranslatef (-RotaCenter[0], -RotaCenter[1], -RotaCenter[2]);
00275    }
00276    
00277    /* find out what colormap is to be displayed */
00278    if (SO->SurfCont->curColPlane) {
00279       /* what's the Cmap for that plane ? */
00280       Cmap = SUMA_CmapOfPlane (SO->SurfCont->curColPlane );
00281       if (Cmap) SUMA_DrawCmap(Cmap); /* create the colormap */
00282    } else {
00283       SUMA_SL_Err("NULL SO->SurfCont->curColPlane");
00284    }   
00285    glPopMatrix();   
00286 
00287    if (LocalHead) fprintf (SUMA_STDOUT,"%s: Flushing or swapping ...\n", FuncName);
00288    
00289    if (SUMAg_SVv[0].X->DOUBLEBUFFER)
00290       glXSwapBuffers(XtDisplay(SO->SurfCont->cmp_ren->cmap_wid), XtWindow(SO->SurfCont->cmp_ren->cmap_wid));
00291    else  
00292       glFlush();
00293 
00294    /* Avoid indirect rendering latency from queuing. */
00295    if (!glXIsDirect(XtDisplay(SO->SurfCont->cmp_ren->cmap_wid), SO->SurfCont->cmp_ren->cmap_context))
00296       glFinish();
00297 
00298    SUMA_RETURNe;
00299 }

00350 {
00351    static char FuncName[]={"SUMA_cmap_wid_expose"};
00352    SUMA_SurfaceObject *SO=NULL;
00353    SUMA_Boolean LocalHead = NOPE;
00354    
00355    SUMA_ENTRY;
00356    
00357    SUMA_LH("called");
00358    SO = (SUMA_SurfaceObject *)clientData;
00359    if (!SO) { SUMA_SL_Err("NULL SO"); SUMA_RETURNe; }
00360    
00361    SUMA_cmap_wid_postRedisplay(w, (XtPointer)SO, NULL);
00362 
00363    SUMA_RETURNe;
00364 }

00089 {
00090    static char FuncName[]={"SUMA_cmap_wid_graphicsInit"};
00091    XVisualInfo *SUMAg_cVISINFO;
00092    SUMA_SurfaceObject *SO=NULL;
00093    SUMA_Boolean LocalHead = NOPE;
00094    
00095    SUMA_ENTRY;
00096    
00097    SUMA_LH("called");
00098    
00099    SO = (SUMA_SurfaceObject *)clientData;
00100    if (!SO) { SUMA_SL_Err("NULL SO"); SUMA_RETURNe; }
00101    
00102    XtVaGetValues(w, GLwNvisualInfo, &SUMAg_cVISINFO, NULL);
00103    SO->SurfCont->cmp_ren->cmap_context = glXCreateContext(XtDisplay(w), SUMAg_cVISINFO,
00104             0,                  /* No sharing. */
00105             True);              /* Direct rendering if possible. */
00106    
00107    /* Setup OpenGL state. */
00108    if (!glXMakeCurrent(XtDisplay(w), XtWindow(w), SO->SurfCont->cmp_ren->cmap_context)) {
00109       fprintf (SUMA_STDERR, "Error %s: Failed in glXMakeCurrent.\n \tContinuing ...\n", FuncName);
00110    }
00111    
00112    /* call context_Init to setup colors and lighting */   
00113    SUMA_cmap_context_Init(SO);
00114 
00115    SUMA_RETURNe;
00116 }

00302 {
00303    static char FuncName[]={"SUMA_cmap_wid_handleRedisplay"};
00304    SUMA_SurfaceObject *SO=NULL;
00305    SUMA_Boolean LocalHead = NOPE;
00306    
00307    SUMA_ENTRY;
00308    
00309    SUMA_LH("Called");
00310   
00311    SO = (SUMA_SurfaceObject *)clientData;
00312    if (!SO) { SUMA_SL_Err("NULL SO"); SUMA_RETURN(NOPE); }
00313    
00314    SUMA_LH("Making cmap_wid current");
00315    if (!glXMakeCurrent(XtDisplay(SO->SurfCont->cmp_ren->cmap_wid), XtWindow(SO->SurfCont->cmp_ren->cmap_wid), SO->SurfCont->cmp_ren->cmap_context)) {
00316       fprintf (SUMA_STDERR, "Error %s: Failed in glXMakeCurrent.\n \tContinuing ...\n", FuncName);
00317    }
00318    
00319    SUMA_cmap_wid_display(SO);
00320    glFinish();
00321    
00322    /* insist on a glXMakeCurrent for surface viewer */
00323    SUMA_LH("Making sv's GLXAREA current");
00324    SUMA_SiSi_I_Insist();
00325    
00326    SUMA_RETURN(YUP);
00327 }

00382 {
00383    static char FuncName[]={"SUMA_cmap_wid_input"};
00384    GLwDrawingAreaCallbackStruct *cd;
00385    KeySym keysym;
00386    XKeyEvent Kev;
00387    XButtonEvent Bev;
00388    XMotionEvent Mev;
00389    char buffer[10], cbuf = '\0', cbuf2='\0';
00390    SUMA_SurfaceObject *SO=NULL;
00391    int xls;
00392    static Time B1time = 0;
00393    static int pButton, mButton, rButton;
00394    static SUMA_Boolean DoubleClick = NOPE;
00395    DList *list = NULL;
00396    SUMA_EngineData *ED = NULL; 
00397    static float height_two_col, width;
00398    int ncol;
00399    SUMA_COLOR_MAP *ColMap = NULL;
00400    static float fov_lim = -1.0;
00401    static SUMA_SurfaceObject *SOcmap=NULL;
00402    SUMA_Boolean LocalHead = NOPE;
00403     
00404    SUMA_ENTRY;
00405    
00406    SUMA_LH("called");
00407    SO = (SUMA_SurfaceObject *)clientData;             /* THIS SO is for the main surface, NOT THE colormap's */
00408    if (!SO) { SUMA_SL_Err("NULL SO"); SUMA_RETURNe; }
00409    
00410    ColMap = SUMA_CmapOfPlane (SO->SurfCont->curColPlane );
00411    if (!ColMap) { SUMA_SL_Err("No Cmap"); SUMA_RETURNe; };
00412    if (ColMap->SO != SOcmap) {
00413       SUMA_LH("New colormap SO");
00414       /* calculate FOV limit for zooming in */
00415       SOcmap = ColMap->SO;
00416       ncol = SOcmap->N_FaceSet / 2;
00417       height_two_col = (SOcmap->MaxDims[1] - SOcmap->MinDims[1]) / (float)ncol * 2.0; /* no need to show more than 2 cols */
00418       width = (SOcmap->MaxDims[0] - SOcmap->MinDims[0]);
00419       fov_lim = 2.0 * atan( (double)height_two_col / ( 2.0 * (double)SUMA_CMAP_VIEW_FROM ) ) * 180 / SUMA_PI; 
00420       if (LocalHead) {
00421          SUMA_Print_Surface_Object(SOcmap, NULL);
00422          fprintf(SUMA_STDERR,"%s: ncol=%d, height = %f, height of 2 col =%f, width=%f, d = %d, fov_lim = %f\n", 
00423             FuncName, ncol, (SOcmap->MaxDims[1] - SOcmap->MinDims[1]), height_two_col,  width, SUMA_CMAP_VIEW_FROM, fov_lim);
00424       }
00425    }  
00426 
00427    /* make sure the color map is the current context */
00428    if (!glXMakeCurrent(XtDisplay(w), XtWindow(w), SO->SurfCont->cmp_ren->cmap_context)) {
00429       fprintf (SUMA_STDERR, "Error %s: Failed in glXMakeCurrent.\n ", FuncName);
00430       SUMA_RETURNe;
00431    }
00432 
00433    /* get the callData pointer */
00434    cd = (GLwDrawingAreaCallbackStruct *) callData;
00435 
00436    Kev = *(XKeyEvent *) &cd->event->xkey; /* RickR's suggestion to comply with ANSI C, no type casting of structures July 04*/
00437    Bev = *(XButtonEvent *) &cd->event->xbutton;
00438    Mev = *(XMotionEvent *) &cd->event->xmotion;
00439    
00440    switch (Kev.type) { /* switch event type */
00441    case KeyPress:
00442       xls = XLookupString((XKeyEvent *) cd->event, buffer, 8, &keysym, NULL);
00443       
00444       /* XK_* are found in keysymdef.h */ 
00445       switch (keysym) { /* keysym */
00446          case XK_r:
00447             {
00448                GLvoid *pixels;
00449                SUMA_LH("Recording");
00450                pixels = SUMA_grabPixels(1, SUMA_CMAP_WIDTH, SUMA_CMAP_HEIGHT);
00451                if (pixels) {
00452                  ISQ_snapsave (SUMA_CMAP_WIDTH, -SUMA_CMAP_HEIGHT, (unsigned char *)pixels, SO->SurfCont->cmp_ren->cmap_wid ); 
00453                  SUMA_free(pixels);
00454                }else {
00455                   SUMA_SLP_Err("Failed to record image.");
00456                }
00457             }
00458             break;
00459          case XK_h:
00460             if (Kev.state & ControlMask){
00461               if (!list) list = SUMA_CreateList();
00462               ED = SUMA_InitializeEngineListData (SE_Help_Cmap);
00463               SUMA_RegisterEngineListCommand ( list, ED,
00464                                          SEF_vp, (void *)ColMap,
00465                                          SES_SumaWidget, NULL, NOPE,
00466                                          SEI_Head, NULL); 
00467               if (!SUMA_Engine (&list)) {
00468                   fprintf(stderr, "Error %s: SUMA_Engine call failed.\n", FuncName);
00469               }    
00470             }
00471             break;
00472          case XK_Z:
00473             {
00474                static SUMA_Boolean BeepedAlready = NOPE;
00475                SO->SurfCont->cmp_ren->FOV /= FOV_IN_FACT; 
00476                if (SO->SurfCont->cmp_ren->FOV < fov_lim) { 
00477                   if (!BeepedAlready) {
00478                      SUMA_BEEP; BeepedAlready = YUP;
00479                   }
00480                   SO->SurfCont->cmp_ren->FOV = fov_lim; 
00481                } else BeepedAlready = NOPE;
00482                if (LocalHead) fprintf(SUMA_STDERR,"%s: Zoom in FOV = %f\n", FuncName, SO->SurfCont->cmp_ren->FOV);
00483                SUMA_cmap_wid_postRedisplay(w, (XtPointer)SO, NULL);
00484             }
00485             break;
00486 
00487          case XK_z:
00488             {
00489                static SUMA_Boolean BeepedAlready = NOPE;
00490                SO->SurfCont->cmp_ren->FOV /= FOV_OUT_FACT; 
00491                if (SO->SurfCont->cmp_ren->FOV > SUMA_CMAP_FOV_INITIAL) { 
00492                   if (!BeepedAlready) {
00493                      SUMA_BEEP; BeepedAlready = YUP;
00494                   }
00495                   SO->SurfCont->cmp_ren->FOV = SUMA_CMAP_FOV_INITIAL; 
00496                } else BeepedAlready = NOPE;
00497                if (LocalHead) fprintf(SUMA_STDERR,"%s: Zoom out FOV = %f\n", FuncName, SO->SurfCont->cmp_ren->FOV);
00498                SUMA_cmap_wid_postRedisplay(w, (XtPointer)SO, NULL);
00499             }
00500             break;
00501          case XK_Home:   
00502             SO->SurfCont->cmp_ren->FOV = SUMA_CMAP_FOV_INITIAL;
00503             SO->SurfCont->cmp_ren->translateVec[0] = SO->SurfCont->cmp_ren->translateVec[1] = SO->SurfCont->cmp_ren->translateVec[2] = 0.0;
00504             SUMA_cmap_wid_postRedisplay(w, (XtPointer)SO, NULL);
00505             break;
00506          case XK_Up:   /*KEY_UP:*/
00507             {
00508                static SUMA_Boolean BeepedAlready = NOPE;   
00509                float tstep = height_two_col / 2 * SO->SurfCont->cmp_ren->FOV/(float)SUMA_CMAP_FOV_INITIAL; 
00510                SO->SurfCont->cmp_ren->translateVec[1] += tstep ;
00511                if (LocalHead) fprintf(SUMA_STDERR,"%s: translateVec[1] = %f\n", FuncName, SO->SurfCont->cmp_ren->translateVec[1]);
00512                if (SO->SurfCont->cmp_ren->translateVec[1] >  SUMA_CMAP_HEIGHT - 20) {
00513                   if (!BeepedAlready) {
00514                      SUMA_BEEP; BeepedAlready = YUP;
00515                   }
00516                      SO->SurfCont->cmp_ren->translateVec[1] -= tstep; 
00517                } else BeepedAlready = NOPE;
00518                SUMA_cmap_wid_postRedisplay(w, (XtPointer)SO, NULL);
00519             }
00520             break;
00521          case XK_Down:   /*KEY_DOWN:*/
00522             {
00523                static SUMA_Boolean BeepedAlready = NOPE;  
00524                float tstep = height_two_col / 2 * SO->SurfCont->cmp_ren->FOV/(float)SUMA_CMAP_FOV_INITIAL; 
00525                SO->SurfCont->cmp_ren->translateVec[1] -=  tstep;
00526                if (SO->SurfCont->cmp_ren->translateVec[1] <  -SUMA_CMAP_HEIGHT + 20) {
00527                   if (!BeepedAlready) {
00528                      SUMA_BEEP; BeepedAlready = YUP;
00529                   }
00530                      SO->SurfCont->cmp_ren->translateVec[1] += tstep; 
00531                } else BeepedAlready = NOPE;
00532                SUMA_cmap_wid_postRedisplay(w, (XtPointer)SO, NULL);
00533             }
00534             break;
00535          
00536       } /* keysym */
00537    break;
00538    
00539    case ButtonPress:
00540       if (LocalHead) fprintf(stdout,"In ButtonPress\n");      
00541       pButton = Bev.button;
00542       if (SUMAg_CF->SwapButtons_1_3 || (SUMAg_CF->ROI_mode && SUMAg_CF->Pen_mode)) {
00543          if (pButton == Button1) pButton = Button3;
00544          else if (pButton == Button3) pButton = Button1;
00545       }
00546      
00547      /* trap for double click */
00548       if (Bev.time - B1time < SUMA_DOUBLE_CLICK_MAX_DELAY) {
00549          if (LocalHead) fprintf(SUMA_STDERR, "%s: Double click.\n", FuncName);
00550          DoubleClick = YUP;
00551       } else {
00552          DoubleClick = NOPE;
00553       }
00554       B1time = Bev.time; 
00555             
00556       switch (pButton) { /* switch type of button Press */
00557          case Button1:
00558             break;
00559          default:
00560             break;
00561       } /* switch type of button Press */
00562       break;
00563       
00564    case ButtonRelease:
00565       if (LocalHead) fprintf(SUMA_STDERR,"%s: In ButtonRelease\n", FuncName); 
00566       rButton = Bev.button;
00567       if (SUMAg_CF->SwapButtons_1_3 || (SUMAg_CF->ROI_mode && SUMAg_CF->Pen_mode)) {
00568          if (rButton == Button1) rButton = Button3;
00569          else if (rButton == Button3) rButton = Button1;
00570       }
00571       switch (rButton) { /* switch type of button Press */
00572          case Button3:
00573             break;
00574          default:
00575             break;
00576       } /* switch type of button Press */
00577       break;
00578       
00579    case MotionNotify:
00580       if (LocalHead) fprintf(stdout,"In MotionNotify\n"); 
00581       if (SUMAg_CF->SwapButtons_1_3 || (SUMAg_CF->ROI_mode && SUMAg_CF->Pen_mode)) {
00582         if (((Mev.state & Button3MotionMask) && (Mev.state & Button2MotionMask)) || ((Mev.state & Button2MotionMask) && (Mev.state & ShiftMask))) {
00583             mButton = SUMA_Button_12_Motion;
00584          } else if(Mev.state & Button3MotionMask) {
00585             mButton = SUMA_Button_1_Motion;
00586          }else if(Mev.state & Button2MotionMask) { 
00587             mButton = SUMA_Button_2_Motion;
00588          }else if(Mev.state & Button1MotionMask) { 
00589             mButton = SUMA_Button_3_Motion;
00590          }else {
00591             break;
00592          } 
00593       } else {
00594          if (((Mev.state & Button1MotionMask) && (Mev.state & Button2MotionMask)) || ((Mev.state & Button2MotionMask) && (Mev.state & ShiftMask))) {
00595             mButton = SUMA_Button_12_Motion;
00596          } else if(Mev.state & Button1MotionMask) {
00597             mButton = SUMA_Button_1_Motion;
00598          }else if(Mev.state & Button2MotionMask) { 
00599             mButton = SUMA_Button_2_Motion;
00600          } else if(Mev.state & Button3MotionMask) { 
00601             mButton = SUMA_Button_3_Motion;
00602          }else {
00603             break;
00604          }
00605       }
00606       
00607       switch (mButton) {
00608          case SUMA_Button_12_Motion:
00609          case SUMA_Button_2_Shift_Motion:
00610             break;
00611          default:
00612             break;
00613       }
00614       
00615       
00616       break;
00617   }/* switch event type */
00618 
00619   /* set up flag to make sure sv regains context */
00620   SUMA_SiSi_I_Insist();
00621    
00622   SUMA_RETURNe;
00623 }

00330 {
00331    static char FuncName[]={"SUMA_cmap_wid_postRedisplay"};
00332    static XtPointer elvis;
00333    int isv;
00334    SUMA_SurfaceObject *SO=NULL;
00335    SUMA_Boolean LocalHead = NOPE;
00336    
00337    SUMA_ENTRY;
00338    
00339    SUMA_LH("cold");
00340    
00341    SO = (SUMA_SurfaceObject *)clientData;
00342    if (!SO) { SUMA_SL_Err("NULL SO"); SUMA_RETURNe; }
00343 
00344    SUMA_register_workproc( SUMA_cmap_wid_handleRedisplay , (XtPointer)SO );
00345    
00346    SUMA_RETURNe;
00347 }

00367 {
00368    static char FuncName[]={"SUMA_cmap_wid_resize"};
00369    SUMA_SurfaceObject *SO=NULL;
00370    SUMA_Boolean LocalHead = NOPE;
00371    
00372    SUMA_ENTRY;
00373    
00374    SUMA_LH("called");
00375    SO = (SUMA_SurfaceObject *)clientData;
00376    if (!SO) { SUMA_SL_Err("NULL SO"); SUMA_RETURNe; }
00377    
00378    SUMA_RETURNe;
00379 }

03331 {
03332    static char FuncName[]={"SUMA_CmapSelectList"};
03333    SUMA_LIST_WIDGET *LW = NULL;
03334    SUMA_Boolean LocalHead = NOPE;
03335    
03336    SUMA_ENTRY;
03337 
03338    if (!SUMAg_CF->scm) {   
03339       SUMAg_CF->scm = SUMA_Build_Color_maps();
03340       if (!SUMAg_CF->scm) {
03341          SUMA_SL_Err("Failed to build color maps.\n");
03342          SUMA_RETURN(NOPE);
03343       }
03344    }
03345       
03346    /* Widget is common to all SUMA */
03347    LW = SUMAg_CF->X->SwitchCmapLst;
03348    
03349    if (!LW) {
03350       SUMA_LH("Allocating widget");
03351       /* need to create widget */
03352       LW = SUMA_AllocateScrolledList   (  "Switch Cmap", SUMA_LSP_SINGLE,
03353                                           NOPE,          NOPE,
03354                                           SO->SurfCont->TopLevelShell, SWP_POINTER_OFF,
03355                                           SUMA_cb_SelectSwitchCmap, (void *)SO,
03356                                           SUMA_cb_SelectSwitchCmap, (void *)SO,
03357                                           SUMA_cb_CloseSwitchCmap, NULL);
03358                                           
03359       SUMAg_CF->X->SwitchCmapLst = LW;
03360       refresh = 1; /* no doubt aboot it */
03361    } else {
03362       if ((void *)SO != LW->Default_Data || (void *)SO != LW->Select_Data) {
03363          /* just update the callback data info in LW */
03364          SUMA_UpdateScrolledListData(LW, (void *)SO, (void *)SO, NULL);
03365       }
03366    }
03367 
03368    if (refresh) {
03369       /* Now creating list*/
03370       if (LW->ALS) {
03371          if (LocalHead) SUMA_S_Err("Freeing the hag.");
03372          LW->ALS = SUMA_FreeAssembleListStruct(LW->ALS);
03373       }
03374       SUMA_LH("Assembling");
03375       LW->ALS = SUMA_AssembleCmapList(SUMAg_CF->scm->CMv, SUMAg_CF->scm->N_maps);
03376       if (!LW->ALS) {
03377          SUMA_SL_Err("Failed to assemble list");
03378          SUMA_RETURN(NOPE);
03379       }
03380       if (LW->ALS->N_clist < 0) {
03381          SUMA_SL_Err("Failed in SUMA_AssembleCmapList");
03382          SUMA_RETURN(NOPE);
03383       }
03384       if (!LW->ALS->N_clist) {
03385          SUMA_SLP_Note ("No cmaps to choose from.");
03386          SUMA_RETURN(NOPE);
03387       }
03388    }
03389    
03390    if (bringup) SUMA_CreateScrolledList ( LW->ALS->clist, LW->ALS->N_clist, NOPE, LW);
03391    
03392    SUMA_RETURN(YUP);
03393 }

03792 {
03793    static char FuncName[]={"SUMA_CreateCmapWidgets"};
03794    char slabel[100];
03795    Widget rct, rcc, rco;
03796    XtVarArgsList arglist=NULL;
03797    SUMA_Boolean LocalHead = NOPE;
03798    
03799    SUMA_ENTRY;
03800 
03801    if (SO->SurfCont->opts_rc) {
03802       SUMA_SL_Err("Non null opts_rc\nThis should not be.");
03803       SUMA_RETURNe;
03804    }
03805    
03806    SO->SurfCont->opts_form = XtVaCreateWidget ("form",
03807       xmFormWidgetClass, parent,
03808       NULL);
03809    
03810    SO->SurfCont->opts_rc = XtVaCreateWidget ("rowcolumn",
03811       xmRowColumnWidgetClass, SO->SurfCont->opts_form,
03812       XmNpacking, XmPACK_TIGHT,
03813       XmNleftAttachment,XmATTACH_FORM ,  
03814       XmNorientation , XmHORIZONTAL ,
03815       XmNmarginHeight , 0 ,
03816       XmNmarginWidth  , 0 ,
03817       NULL);
03818 
03819    { /* the threshold bar */
03820       rct = XtVaCreateWidget ("rowcolumn",
03821          xmRowColumnWidgetClass, SO->SurfCont->opts_rc,
03822          XmNpacking, XmPACK_TIGHT, 
03823          XmNresizeHeight, False, /* important that this rc is not to be resized automatically,
03824                                     otherwise, the fix SUMA_FORCE_SCALE_HEIGHT will fail */
03825          XmNresizeWidth, False,
03826          XmNwidth, SUMA_SCALE_WIDTH, 
03827          XmNorientation , XmVERTICAL ,
03828          XmNmarginHeight , 0 ,
03829          XmNmarginWidth  , 0 ,
03830          NULL);
03831       /* convenient common arguments for scales */
03832       arglist = XtVaCreateArgsList( NULL,
03833                                     XmNshowValue, True,
03834                                     XmNmaximum, 255,
03835                                     XmNscaleMultiple, 5,
03836                                     XmNheight,  SUMA_SCALE_HEIGHT,
03837                                     XmNuserData, (XtPointer)0,
03838                                     NULL);
03839                   
03840       /* put a string on top of the scale
03841       Can use XmNtitleString but it is placed on the side. 
03842       Too much waisted space */
03843       #if 0
03844       sprintf(slabel,"Thr.");
03845       SO->SurfCont->thr_lb = XtVaCreateManagedWidget (slabel, 
03846                                           xmLabelWidgetClass, rct,
03847                                           XmNwidth, SUMA_SCALE_WIDTH,
03848                                           XmNrecomputeSize, False,   /* don't let it change size, it messes up the slider */ 
03849                                           NULL);
03850       #else
03851       {
03852          int colw[]={6};
03853          char *lhint[]={ "Threshold Value", NULL};
03854          char *lhelp[]={ SUMA_SurfContHelp_SetThreshTblr0, NULL};
03855          if (!SO->SurfCont->SetThrScaleTable->cells) {
03856             SUMA_CreateTable( rct,
03857                               1, 1, 
03858                               NULL, NULL,  
03859                               lhint, NULL,  
03860                               lhelp, NULL,  
03861                               colw, YUP, SUMA_float, 
03862                               SUMA_SetScaleThr, (void *)SO,
03863                               NULL, NULL,
03864                               NULL, NULL,  
03865                               SO->SurfCont->SetThrScaleTable);                                     
03866          }
03867       }
03868       #endif
03869       /* add a vertical scale for the intensity */
03870       SO->SurfCont->thr_sc = XtVaCreateManagedWidget("Thr.",
03871                                           xmScaleWidgetClass, rct,
03872                                           XtVaNestedList, arglist,
03873                                           NULL);
03874 
03875       XtAddCallback (SO->SurfCont->thr_sc, XmNvalueChangedCallback, SUMA_cb_set_threshold, (XtPointer) SO);
03876       
03877       XtAddCallback (SO->SurfCont->thr_sc, XmNdragCallback, SUMA_cb_set_threshold_label, (XtPointer) SO); 
03878       
03879       #if 0
03880       /* put a string for the pvalue */
03881       sprintf(slabel,"[N/A]");
03882       SO->SurfCont->thrstat_lb = XtVaCreateManagedWidget (slabel, 
03883                                           xmLabelWidgetClass, rct,
03884                                           NULL);
03885       #endif
03886       XtManageChild (rct);
03887 
03888    }/* the threshold bar */
03889                      
03890    if (arglist) XtFree(arglist); arglist = NULL;
03891    
03892    {/* the color bar */
03893       Widget rcc2;
03894       rcc = XtVaCreateWidget ("rowcolumn",
03895          xmRowColumnWidgetClass, SO->SurfCont->opts_rc,
03896          XmNpacking, XmPACK_TIGHT, 
03897          XmNorientation , XmVERTICAL ,
03898          XmNmarginHeight , 0 ,
03899          XmNmarginWidth  , 0 ,
03900          NULL);
03901       
03902       sprintf(slabel,"   ");
03903       SO->SurfCont->cmaptit_lb = XtVaCreateManagedWidget (slabel, 
03904                                           xmLabelWidgetClass, rcc,
03905                                           NULL);
03906       /* need another rc for the cmap to avoid having the glxarea resized by cmaptit_lb
03907       and SwitchCmapMenu */
03908       rcc2 = XtVaCreateWidget ("rowcolumn",
03909          xmRowColumnWidgetClass, rcc,
03910          XmNpacking, XmPACK_TIGHT, 
03911          XmNorientation , XmHORIZONTAL ,
03912          XmNmarginHeight , 0 ,
03913          XmNmarginWidth  , 0 ,
03914          NULL);
03915       
03916       /* open me a glxarea */
03917       SO->SurfCont->cmp_ren->cmap_wid = XtVaCreateManagedWidget("glxarea",
03918                                           glwDrawingAreaWidgetClass, rcc2,
03919                                           GLwNvisualInfo, SUMAg_SVv[0].X->VISINFO,
03920                                           XtNcolormap, SUMAg_SVv[0].X->CMAP,
03921                                           XmNwidth,   SUMA_CMAP_WIDTH,
03922                                           XmNheight,  SUMA_CMAP_HEIGHT,
03923                                           NULL);
03924 
03925       XtManageChild (rcc2);
03926       
03927       /* add me some callbacks */
03928       XtAddCallback(SO->SurfCont->cmp_ren->cmap_wid, GLwNginitCallback, SUMA_cmap_wid_graphicsInit, (XtPointer )SO);
03929       XtAddCallback(SO->SurfCont->cmp_ren->cmap_wid, GLwNexposeCallback, SUMA_cmap_wid_expose, (XtPointer )SO);
03930       XtAddCallback(SO->SurfCont->cmp_ren->cmap_wid, GLwNresizeCallback, SUMA_cmap_wid_resize, (XtPointer )SO);
03931       XtAddCallback(SO->SurfCont->cmp_ren->cmap_wid, GLwNinputCallback, SUMA_cmap_wid_input, (XtPointer )SO);
03932       
03933       XtManageChild (rcc);
03934    }  /* the colorbar */
03935    
03936    /* The options will be created as needed, when colorplanes are switched.
03937    see SUMA_InitializeColPlaneShell */
03938    
03939    XtManageChild (SO->SurfCont->opts_rc);
03940    XtManageChild (SO->SurfCont->opts_form);
03941    SUMA_RETURNe;
03942 } 

01713 {
01714    static char FuncName[]={"SUMA_CreateTable"};
01715    int i, j, n, titw, xmw;
01716    char *tmp;
01717    Widget rco, rcc;
01718    XtPointer cd;
01719    SUMA_Boolean LocalHead = NOPE;
01720    
01721    SUMA_ENTRY;                        
01722 
01723    if (!TF) { SUMA_SL_Err("NULL TF"); SUMA_RETURNe; }
01724    TF->Ni = Ni; TF->Nj = Nj; TF->editable = editable; 
01725    TF->cwidth = (int *)SUMA_calloc(TF->Nj, sizeof(int)); for (j=0; j<TF->Nj; ++j) TF->cwidth[j] = cwidth[j];
01726    if(col_tit) TF->HasColTit = YUP; else TF->HasColTit = NOPE;
01727    if(row_tit) TF->HasRowTit = YUP; else TF->HasRowTit = NOPE;
01728    TF->cells = (Widget *)SUMA_malloc(sizeof(Widget)*TF->Ni*TF->Nj);
01729    if (!TF->cells) {  SUMA_SL_Crit("Failed to allocate"); SUMA_RETURNe; }
01730    TF->NewValueCallback = NewValueCallback;
01731    TF->NewValueCallbackData = cb_data;
01732    TF->TitLabelEVHandler = TitLabelEVHandler;
01733    TF->TitLabelEVHandlerData = TitLabelEVHandlerData;
01734    TF->CellEVHandler = CellEVHandler;
01735    TF->CellEVHandlerData = CellEVHandlerData;
01736    TF->type = type;
01737    switch (TF->type) {
01738       case SUMA_int:
01739       case SUMA_float:
01740          TF->num_value= (float *)SUMA_calloc(TF->Nj*TF->Ni, sizeof(float));
01741          break;
01742       case SUMA_string:
01743          TF->str_value= (char **)SUMA_malloc(TF->Nj*TF->Ni * sizeof(char *));
01744          for (i=0; i<TF->Nj*TF->Ni; ++i) TF->str_value[i] = NULL;
01745          break;
01746       default:
01747          SUMA_SL_Err("Comme tu es bete!");
01748          SUMA_RETURNe;
01749          break;  
01750    }
01751    /* An outer row column to keep the inner one from resizing with parent 
01752    YOU COULD HAVE SET XmNadjustLast to False, instead ....*/
01753    TF->rc = XtVaCreateManagedWidget ("rowcolumn",
01754       xmRowColumnWidgetClass, parent,
01755       XmNorientation , XmHORIZONTAL ,
01756       XmNpacking, XmPACK_TIGHT,
01757       XmNmarginHeight, 0,
01758       XmNmarginWidth, 0,
01759       NULL);
01760        
01761    /* Le row column to contain the table's columns*/
01762    rco = XtVaCreateManagedWidget ("rowcolumn",
01763       xmRowColumnWidgetClass, TF->rc,
01764       XmNorientation , XmVERTICAL ,
01765       XmNpacking, XmPACK_TIGHT,
01766       XmNnumColumns, 1,
01767       XmNmarginHeight, 0,
01768       XmNmarginWidth, 0, 
01769       NULL);
01770 
01771    /* must fill up row by row, each column is a separate bloody rc to allow for alignments */
01772    for (i=0; i<TF->Ni; ++i) {   /* for each row */
01773       rcc = XtVaCreateManagedWidget ("rowcolumn",
01774          xmRowColumnWidgetClass, rco,
01775          XmNorientation , XmHORIZONTAL ,
01776          XmNmarginHeight, 0,
01777          XmNmarginHeight, 0,
01778          XmNmarginWidth, 0, 
01779          NULL);
01780       
01781       if (i == 0 && TF->HasColTit) { /* This is left here to show that I tried using different packing methods
01782                                        to get the title to appear centered with the cell entries below.
01783                                        That did nothing. Setting packing to tight in all cases and padding
01784                                        the titles to fit the cell entry widths works fine */
01785          XtVaSetValues (rcc, XmNpacking, XmPACK_TIGHT, NULL); 
01786       } else {
01787          XtVaSetValues (rcc, XmNpacking, XmPACK_TIGHT, NULL); 
01788       }
01789       
01790       for (j=0; j<TF->Nj; ++j) { /* for each column */
01791          n = j * TF->Ni + i;
01792          switch (SUMA_cellvariety(TF, n)) {
01793             case SUMA_ROW_TIT_CELL: /* row's title */
01794                if (LocalHead) fprintf(SUMA_STDERR,"%s:\nAdding [%d %d] (%d) %s\n", FuncName, i, j, n, row_tit[i]);
01795                #if 0
01796                   TF->cells[n] = XtVaCreateManagedWidget(row_tit[i],  
01797                                                 xmLabelWidgetClass, rcc, 
01798                                                 NULL);
01799                #else
01800                   TF->cells[n] = XtVaCreateManagedWidget("column title",   
01801                                                    xmTextFieldWidgetClass, rcc,
01802                                                    XmNvalue, row_tit[i],
01803                                                    XmNmarginHeight, 0,
01804                                                    XmNmarginWidth, 0,
01805                                                    XmNmarginTop, 0,
01806                                                    XmNmarginBottom, 0,
01807                                                    XmNmarginLeft, 0,
01808                                                    XmNmarginRight, 0,
01809                                                    XmNeditable, False, 
01810                                                    XmNshadowThickness , 0,          /* hide the border */
01811                                                    XmNcursorPositionVisible, False, /* hide the cursor */
01812                                                    XmNcolumns, strlen(row_tit[i]), 
01813                                                    NULL);
01814                #endif
01815                if (!TF->TitLabelEVHandlerData) cd = (XtPointer) TF; else cd = (XtPointer)TF->TitLabelEVHandlerData;
01816                if (TF->TitLabelEVHandler) {
01817                   /* insert handler to catch clicks on titles */
01818                   XtInsertEventHandler( TF->cells[n] ,      /* handle events in title cell */
01819                               ButtonPressMask ,  /* button presses */
01820                               FALSE ,            /* nonmaskable events? */
01821                               TF->TitLabelEVHandler,  /* handler */
01822                               cd ,   /* client data */
01823                               XtListTail ) ; 
01824                }
01825                if (row_hint)  MCW_register_hint( TF->cells[n], row_hint[i] );
01826                if (row_help)  MCW_register_help( TF->cells[n], row_help[i] ) ;
01827                break;
01828                
01829             case SUMA_COL_TIT_CELL: /* column's title */
01830                if (LocalHead) fprintf(SUMA_STDERR,"%s:\nAdding [%d %d] (%d) %s\n", FuncName, i, j, n, col_tit[j]);
01831                /* padd to fit cell entry fields*/
01832                if (i == 0 && j != 0 && TF->HasColTit) { 
01833                   titw = TF->cwidth[j]; 
01834                   /* set the margins to meet those of cell entries */
01835                   xmw = 5;
01836                } else {
01837                   titw = TF->cwidth[j];
01838                   /* set the margins to meet those of Labels */
01839                   xmw = 0;
01840                }
01841                #if 0
01842                   TF->cells[n] = XtVaCreateManagedWidget(tmp,  
01843                                                 xmLabelWidgetClass, rcc,
01844                                                 NULL);
01845                #else 
01846                   TF->cells[n] = XtVaCreateManagedWidget("column title",   
01847                                                    xmTextFieldWidgetClass, rcc,
01848                                                    XmNvalue, col_tit[j],
01849                                                    XmNmarginHeight, 0,
01850                                                    XmNmarginWidth, xmw,
01851                                                    XmNmarginTop, 0,
01852                                                    XmNmarginBottom, 0,
01853                                                    XmNmarginLeft, 0,
01854                                                    XmNmarginRight, 0,
01855                                                    XmNeditable, False, 
01856                                                    XmNshadowThickness , 0,          /* hide the border */
01857                                                    XmNcursorPositionVisible, False, /* hide the cursor */
01858                                                    XmNcolumns, titw, 
01859                                                    NULL);
01860                #endif
01861                if (i == 0 && j != 0) { 
01862                   XtVaSetValues( TF->cells[n], XmNalignment, XmALIGNMENT_BEGINNING, NULL);
01863                }
01864                
01865                /* insert handler to catch clicks on titles */
01866                if (!TF->TitLabelEVHandlerData) cd = (XtPointer) TF; else cd = (XtPointer)TF->TitLabelEVHandlerData;
01867                if (TF->TitLabelEVHandler) {
01868                   /* insert handler to catch clicks on titles */
01869                   XtInsertEventHandler( TF->cells[n] ,      /* handle events in title cell */
01870                               ButtonPressMask ,  /* button presses */
01871                               FALSE ,            /* nonmaskable events? */
01872                               TF->TitLabelEVHandler,  /* handler */
01873                               cd ,   /* client data */
01874                               XtListTail ) ; 
01875                }                 
01876                if (col_hint)  MCW_register_hint( TF->cells[n], col_hint[j] );
01877                if (col_help)  MCW_register_help( TF->cells[n], col_help[j] ) ;
01878                break;
01879             case SUMA_ENTRY_CELL: /* entry cell */
01880                if (LocalHead) fprintf(SUMA_STDERR,"%s:\nAdding [%d %d] (%d) entry cell\n", FuncName, i, j, n);
01881                TF->cells[n] = XtVaCreateManagedWidget("entry",  
01882                                                    xmTextFieldWidgetClass, rcc,
01883                                                    XmNuserData, (XtPointer)n,
01884                                                    XmNvalue, "-",
01885                                                    XmNmarginHeight, 0,
01886                                                    XmNmarginTop, 0,
01887                                                    XmNmarginBottom, 0, 
01888                                                    NULL);
01889                if (col_help || col_hint || row_help || row_hint)  
01890                   MCW_register_help( TF->cells[n], "Hints and help messages\n"
01891                                                    "are attached to table's\n"
01892                                                    "column and row titles."  ) ;
01893                if (TF->cwidth[j] > 0) {  XtVaSetValues(TF->cells[n], XmNcolumns, TF->cwidth[j], NULL); }
01894                if (!TF->editable) { 
01895                   SUMA_SetCellEditMode(TF, i, j, 0);
01896                } else {
01897                   SUMA_SetCellEditMode(TF, i, j, 1);
01898                }
01899                /* insert handlers if any */
01900                if (!TF->CellEVHandlerData) cd = (XtPointer) TF; else cd = (XtPointer)TF->CellEVHandlerData;
01901                if (TF->CellEVHandler) {
01902                   /* insert handler to catch clicks on cells */
01903                   XtInsertEventHandler( TF->cells[n] ,      /* handle events in cell */
01904                               ButtonPressMask ,  /* button presses */
01905                               FALSE ,            /* nonmaskable events? */
01906                               TF->CellEVHandler,  /* handler */
01907                               cd ,   /* client data */
01908                               XtListTail ) ; 
01909                }                 
01910                break;
01911             default:
01912                SUMA_SL_Err("Bad cell type");
01913                SUMA_RETURNe;
01914                break;
01915          }     
01916       } /* for i */
01917    } /* for j */
01918    
01919    SUMA_RETURNe;
01920 }

03067 {
03068    static char FuncName[]={"SUMA_CreateUpdatableCmapMenu"};
03069    SUMA_MenuItem *SwitchCmap_Menu = NULL;
03070    SUMA_Boolean LocalHead = NOPE;
03071 
03072    SUMA_ENTRY;
03073 
03074    if (!SUMAg_CF->scm) {   
03075       SUMAg_CF->scm = SUMA_Build_Color_maps();
03076       if (!SUMAg_CF->scm) {
03077          SUMA_SL_Err("Failed to build color maps.\n");
03078          SUMA_RETURNe;
03079       }
03080    }
03081    
03082    if (!SO->SurfCont->rc_CmapCont) { /* first pass, create placement container */
03083       SO->SurfCont->rc_CmapCont = XtVaCreateWidget ("rowcolumn",
03084       xmRowColumnWidgetClass, SO->SurfCont->rccm_swcmap,
03085       XmNpacking, XmPACK_TIGHT, 
03086       XmNorientation , XmHORIZONTAL ,
03087       XmNmarginHeight, 0 ,
03088       XmNmarginWidth , 0 ,
03089       NULL);   
03090    }
03091 
03092    SUMA_LH("Forming CmapMenu");
03093    SwitchCmap_Menu = SUMA_FormSwitchCmapMenuVector(SUMAg_CF->scm->CMv, SUMAg_CF->scm->N_maps);
03094    if (SwitchCmap_Menu) {
03095       /*SO->SurfCont->cmapswtch_pb = XtVaCreateManagedWidget ("Switch", 
03096                         xmPushButtonWidgetClass, rcc, 
03097                         NULL);
03098       XtAddCallback (SO->SurfCont->cmapswtch_pb, XmNactivateCallback, SUMA_cb_ColMap_Switch, (XtPointer) SO);
03099       */
03100       if (SO->SurfCont->SwitchCmapMenu) {
03101          SUMA_LH("Freeing old menu");
03102          XtDestroyWidget(SO->SurfCont->SwitchCmapMenu[0]); /*kill the menu widget */
03103          SUMA_free(SO->SurfCont->SwitchCmapMenu);   /* free the vector */
03104       }
03105       /* create a new one allocate for one more spot for the parent widget. 
03106          (more additions for sub-menus, see how SUMA_BuildMenu works )*/
03107       SO->SurfCont->SwitchCmapMenu = (Widget *)SUMA_malloc(sizeof(Widget)*(SUMAg_CF->scm->N_maps+1));  
03108       SUMA_BuildMenuReset(10);
03109       SO->SurfCont->N_CmapMenu = SUMA_BuildMenu (SO->SurfCont->rc_CmapCont, XmMENU_OPTION, /* populate it */
03110                         "Cmp", '\0', YUP, SwitchCmap_Menu, 
03111                         (void *)SO,  
03112                         "Switch between available color maps. (BHelp for more)", 
03113                         SUMA_SurfContHelp_Cmp, 
03114                         SO->SurfCont->SwitchCmapMenu );
03115       XtInsertEventHandler( SO->SurfCont->SwitchCmapMenu[0] ,      /* handle events in optmenu */
03116                         ButtonPressMask ,  /* button presses */
03117                         FALSE ,            /* nonmaskable events? */
03118                         SUMA_optmenu_EV ,  /* handler */
03119                         (XtPointer) SO ,   /* client data */
03120                         XtListTail ) ;
03121       XtManageChild (SO->SurfCont->SwitchCmapMenu[0]);
03122       /* Now destroy the SwitchCmap_Menu */
03123       SwitchCmap_Menu = SUMA_FreeMenuVector(SwitchCmap_Menu, SUMAg_CF->scm->N_maps);
03124    }
03125 
03126    XtManageChild(SO->SurfCont->rc_CmapCont);
03127 
03128    SUMA_RETURNe;
03129 }

03660 {
03661    static char FuncName[]={"SUMA_CreateXhairWidgets"};
03662    char *Xhair_tit[]=   {  "Xhr ", NULL};
03663    char *Xhair_hint[]=  {  "Crosshair coordinates.", NULL};
03664    char *Xhair_help[]=  {  SUMA_SurfContHelp_Xhr , NULL};
03665    char *Node_tit[]=    {  "Node"   , NULL};
03666    char *Node_hint[]=   {  "Node index", NULL};
03667    char *Node_help[]=   {  SUMA_SurfContHelp_Node , NULL};
03668    char *Face_tit[]=    {  "Tri ", NULL};
03669    char *Face_hint[]=   {  "1- Triangle index, 2- Nodes forming tiangle", NULL};
03670    char *Face_help[]=   {  SUMA_SurfContHelp_Tri , NULL};
03671    char *Data_tit[]=    {  "    ", "Intens", "Thresh", "Bright" , NULL};
03672    char *Data_colhint[]=      {  "Data Values at node in focus", 
03673                                  "Intensity (I) value", 
03674                                  "Threshold (T) value", 
03675                                  "Brightness modulation (B) value" , NULL};
03676    char *Data_colhelp[]=      {  SUMA_SurfContHelp_NodeValTblc0, 
03677                                  SUMA_SurfContHelp_NodeValTblc1, 
03678                                  SUMA_SurfContHelp_NodeValTblc2, 
03679                                  SUMA_SurfContHelp_NodeValTblc3 , NULL}; 
03680    
03681    char *Data_rtit[]=      {  "    ", "Val " , NULL};
03682    char *Data_rowhint[]=   {  "Data Values at node in focus", 
03683                               "Data Values at node in focus" , NULL};
03684    char *Data_rowhelp[]=   {  SUMA_SurfContHelp_NodeValTblr0, 
03685                               SUMA_SurfContHelp_NodeValTblr0 , NULL};
03686    
03687    char *Label_tit[]=   {  "Lbl ", NULL};
03688    char *Label_hint[]=  {  "Color at node in focus", NULL};
03689    char *Label_help[]=  {  SUMA_SurfContHelp_NodeLabelTblr0 , NULL};
03690    
03691    Widget rcc;
03692    
03693    SUMA_Boolean LocalHead = NOPE;
03694    
03695    SUMA_ENTRY;
03696    
03697    /* a row column to contain them all */
03698    rcc = XtVaCreateWidget ("rowcolumn",
03699       xmRowColumnWidgetClass, parent,
03700       XmNpacking, XmPACK_TIGHT,
03701       XmNleftAttachment,XmATTACH_FORM ,  
03702       XmNorientation , XmVERTICAL ,
03703       XmNmarginHeight , 0 ,
03704       XmNmarginWidth  , 0 ,
03705       NULL);
03706    
03707    /* a simple table with the xhair coordinate */
03708    SUMA_LH("Creating Xhair coordinates table");
03709    {
03710       int colw[] = { 4, 27 };
03711       SUMA_CreateTable(rcc, 
03712          1, 2,
03713          Xhair_tit, NULL,
03714          Xhair_hint, NULL,
03715          Xhair_help, NULL,
03716          colw, YUP, SUMA_string,
03717          SUMA_XhairInput, (void*)SO,
03718          NULL, NULL, 
03719          NULL, NULL,  
03720          SO->SurfCont->XhairTable);
03721    }
03722    /* a table for a node's index */      
03723    SUMA_LH("Creating node table");
03724    {
03725       int colw[]={4, 6, 19};
03726       SUMA_CreateTable(rcc, 
03727          1, 3,
03728          Node_tit, NULL,
03729          Node_hint, NULL,
03730          Node_help, NULL,
03731          colw, YUP, SUMA_int,
03732          SUMA_NodeInput, (void*)SO,
03733          NULL, NULL, 
03734          NULL, NULL,  
03735          SO->SurfCont->NodeTable);
03736       /* disable the 3rd entry cell */
03737       SUMA_SetCellEditMode(SO->SurfCont->NodeTable, 0, 2, 0);
03738    }
03739    /* a table for the triangle in focus */      
03740    SUMA_LH("Creating Face  table");
03741    {
03742       int colw[]={4, 6, 19}  ; 
03743       SUMA_CreateTable(rcc, 
03744          1, 3,
03745          Face_tit, NULL,
03746          Face_hint, NULL,
03747          Face_help, NULL,
03748          colw, YUP, SUMA_int,
03749          SUMA_TriInput, (void*)SO,
03750          NULL, NULL, 
03751          NULL, NULL,  
03752          SO->SurfCont->FaceTable);
03753       /* disable the 3rd entry cell */
03754       SUMA_SetCellEditMode(SO->SurfCont->FaceTable, 0, 2, 0);   
03755    }
03756    /* a table for the Dset values at node in focus */      
03757    SUMA_LH("Creating Dset Val  table");
03758    {
03759       int colw[]={ 4, 7, 7, 7};
03760       SUMA_CreateTable(rcc, 
03761          2, 4,
03762          Data_rtit, Data_tit,
03763          Data_rowhint, Data_colhint,
03764          Data_rowhelp, Data_colhelp,
03765          colw, NOPE, SUMA_float,
03766          NULL, NULL,
03767          NULL, NULL, 
03768          NULL, NULL,  
03769          SO->SurfCont->DataTable);
03770    }
03771    /* a table for a node's label*/      
03772    SUMA_LH("Creating label  table");
03773    {
03774       int colw[]={4, 26};
03775       SUMA_CreateTable(rcc, 
03776          1, 2,
03777          Label_tit, NULL,
03778          Label_hint, NULL,
03779          Label_help, NULL, 
03780          colw, NOPE, SUMA_string,
03781          NULL, NULL,
03782          NULL, NULL, 
03783          NULL, NULL,  
03784          SO->SurfCont->LabelTable);
03785    }      
03786    XtManageChild(rcc);
03787    SUMA_RETURNe;
03788    
03789 }

00186 {
00187    static char FuncName[]={"SUMA_DrawCmap"};
00188    float orig[3]={ SUMA_CMAP_ORIGIN };
00189    int i;
00190    float topright[3] = { SUMA_CMAP_TOPLEFT };
00191    SUMA_Boolean LocalHead = NOPE;
00192    
00193    SUMA_ENTRY;
00194    
00195    SUMA_LH("called");
00196 
00197    if (!Cmap->SO) {
00198       SUMA_LH("Creating Cmap's SO");
00199       Cmap->SO = SUMA_Cmap_To_SO(Cmap, orig, topright, 0);
00200       if (!Cmap->SO) { SUMA_SL_Err("Failed to create SO"); }
00201    }
00202     
00203    /* This allows each node to follow the color specified when it was drawn */ 
00204    glColorMaterial(GL_FRONT, GL_AMBIENT_AND_DIFFUSE); 
00205    glEnable(GL_COLOR_MATERIAL);
00206 
00207    /*Now setup various pointers*/
00208    glEnableClientState (GL_COLOR_ARRAY);
00209    glEnableClientState (GL_VERTEX_ARRAY);
00210    glEnableClientState (GL_NORMAL_ARRAY);
00211    glColorPointer (4, GL_FLOAT, 0, Cmap->SO->PermCol);
00212    glVertexPointer (3, GL_FLOAT, 0, Cmap->SO->glar_NodeList);
00213    glNormalPointer (GL_FLOAT, 0, Cmap->SO->glar_NodeNormList);
00214 
00215    SUMA_SET_GL_RENDER_MODE(SRM_Fill); 
00216    glDrawElements (GL_TRIANGLES, (GLsizei)Cmap->SO->N_FaceSet*3, GL_UNSIGNED_INT, Cmap->SO->glar_FaceSetList);
00217    
00218    /* Here you could draw a contour around the color cells. 
00219    But you'll need to raise the contour over the filled polygons because they'll get
00220    covered otherwise */ 
00221    #if 0
00222    { 
00223       GLfloat *LineCol=NULL;   
00224       LineCol = (GLfloat *)SUMA_calloc(Cmap->SO->N_Node*4, sizeof(GLfloat));
00225       for (i=0; i<Cmap->SO->N_Node; ++i) { LineCol[4*i] = LineCol[4*i+1] = LineCol[4*i+2] = 0.1; LineCol[4*i+3] = 1.0; }
00226       glColorPointer (4, GL_FLOAT, 0, LineCol);
00227       SUMA_SET_GL_RENDER_MODE(SRM_Line); 
00228       glDrawElements (GL_TRIANGLES, (GLsizei)Cmap->SO->N_FaceSet*3, GL_UNSIGNED_INT, Cmap->SO->glar_FaceSetList);
00229       SUMA_free(LineCol); LineCol = NULL;
00230    }
00231    #endif
00232    
00233    SUMA_RETURNe;
00234 }

04049 {
04050    static char FuncName[]={"SUMA_FormSwitchCmapMenuVector"};
04051    SUMA_MenuItem *menu = NULL;
04052    int i;
04053    void (*callback)();
04054    NI_element *nel = NULL;
04055    SUMA_Boolean LocalHead = NOPE;
04056 
04057    SUMA_ENTRY;
04058    
04059    if (!CMv) { SUMA_SL_Err("NULL CMv"); SUMA_RETURN (menu);}
04060    if (N_maps <=0) { SUMA_SL_Err("N_maps <=0"); SUMA_RETURN (menu);}
04061 
04062    callback = SUMA_cb_SwitchCmap;
04063    
04064    /* Allocate for menu */
04065    menu = (SUMA_MenuItem *)SUMA_malloc(sizeof(SUMA_MenuItem)*(N_maps+1));
04066    
04067    /* fillup menu */
04068    for (i=0; i < N_maps; ++i) {
04069       menu[i].label = SUMA_copy_string(CMv[i]->Name);
04070       menu[i].class = &xmPushButtonWidgetClass;
04071       menu[i].mnemonic = '\0';
04072       menu[i].accelerator = NULL;
04073       menu[i].accel_text = NULL;
04074       menu[i].callback = callback;
04075       menu[i].callback_data = (XtPointer)CMv[i]; /* (used to be i+1)DO NOT USE THE 0 for the first button. 0th index is reserved for the rc widget */
04076       menu[i].subitems = NULL;
04077    }
04078    
04079    /* add the stop sign. That's what SUMA_BuildMenu uses to figure out the number of elements */
04080    menu[N_maps].label = NULL;
04081       
04082    SUMA_RETURN (menu);
04083 }

03966 {
03967    static char FuncName[]={"SUMA_FormSwitchColMenuVector"};
03968    SUMA_MenuItem *menu = NULL;
03969    int i;
03970    void (*callback)();
03971    NI_element *nel = NULL;
03972    SUMA_Boolean LocalHead = NOPE;
03973 
03974    SUMA_ENTRY;
03975    
03976    if (!SO) { SUMA_SL_Err("NULL SO"); SUMA_RETURN (menu);}
03977    if (!SO->SurfCont) { SUMA_SL_Err("NULL SO->SurfCont"); SUMA_RETURN (menu);}
03978    if (!SO->SurfCont->curColPlane) { SUMA_SL_Err("NULL SO->SurfCont->curColPlane"); SUMA_RETURN (menu);}
03979    if (!SO->SurfCont->curColPlane->dset_link) { SUMA_SL_Err("NULL SO->SurfCont->curColPlane->dset_link"); SUMA_RETURN (menu);}
03980 
03981    nel = SO->SurfCont->curColPlane->dset_link->dnel;
03982    if (!nel) { SUMA_SL_Err("NULL nel"); SUMA_RETURN (menu);}
03983    if (!nel->vec_num) { SUMA_SL_Err("no vecs"); SUMA_RETURN (menu);}
03984    
03985    /* decide on callback */
03986    switch (what) {
03987       case 0: 
03988          callback = SUMA_cb_SwitchIntensity;
03989          break;
03990       case 1:
03991          callback = SUMA_cb_SwitchThreshold;
03992          break;
03993       case 2:
03994          callback = SUMA_cb_SwitchBrightness;
03995          break;
03996       default:
03997          SUMA_SL_Err("No such what");
03998          SUMA_RETURN(menu);
03999    }
04000    
04001    /* Allocate for menu */
04002    menu = (SUMA_MenuItem *)SUMA_malloc(sizeof(SUMA_MenuItem)*(nel->vec_num+1));
04003    
04004 
04005    /* fillup menu */
04006    for (i=0; i < nel->vec_num; ++i) {
04007       menu[i].label = SUMA_DsetColLabelCopy(SO->SurfCont->curColPlane->dset_link, i, 1);
04008       menu[i].class = &xmPushButtonWidgetClass;
04009       menu[i].mnemonic = '\0';
04010       menu[i].accelerator = NULL;
04011       menu[i].accel_text = NULL;
04012       menu[i].callback = callback;
04013       menu[i].callback_data = (XtPointer)i+1; /* DO NOT USE THE zeroth item */
04014       menu[i].subitems = NULL;
04015    }
04016    
04017    /* add the stop sign. That's what SUMA_BuildMenu uses to figure out the number of elements */
04018    menu[nel->vec_num].label = NULL;
04019    
04020    *N_items = nel->vec_num;
04021       
04022    SUMA_RETURN (menu);
04023 }

03945 {
03946    static char FuncName[]={"SUMA_FreeMenuVector"};
03947    int i;
03948    
03949    SUMA_ENTRY;
03950    
03951    if (!menu) {SUMA_RETURN(NULL);}
03952    if (Nels <= 0) {SUMA_RETURN(NULL);}
03953    
03954    for (i=0; i<Nels; ++i) {
03955       if (menu[i].label) SUMA_free(menu[i].label);
03956       if (menu[i].accelerator) SUMA_free(menu[i].accelerator);
03957       if (menu[i].accel_text) SUMA_free(menu[i].accel_text);
03958       if (menu[i].subitems) { SUMA_SL_Err("Don't know how to free subitems yet."); }
03959    }
03960    SUMA_free(menu);
03961    
03962    SUMA_RETURN(NULL);
03963 }

01605 {
01606    static char FuncName[]={"SUMA_FreeTableField"};
01607    int i;
01608    
01609    SUMA_ENTRY;
01610 
01611    if (!TF) SUMA_RETURN(NULL);
01612 
01613    if (TF->cells) SUMA_free(TF->cells);
01614    if (TF->cwidth) SUMA_free(TF->cwidth);
01615    if (TF->num_value) SUMA_free(TF->num_value);
01616    if (TF->str_value) { 
01617       for (i=0; i<TF->Nj*TF->Ni; ++i) if (TF->str_value[i]) SUMA_free(TF->str_value[i]); 
01618       SUMA_free(TF->str_value);
01619    }
01620    SUMA_free(TF);
01621 
01622    SUMA_RETURN(NULL);
01623 
01624 }

04448 {
04449    static char FuncName[]={"SUMA_Init_SurfCont_CrossHair"};
04450    int i;
04451    SUMA_Boolean LocalHead = NOPE;
04452 
04453    SUMA_ENTRY;
04454 
04455    if (!SO) SUMA_RETURN(YUP);
04456 
04457    /* set the cross hair and related fields */
04458    SUMA_UpdateTriField(SO);
04459    SUMA_UpdateNodeField(SO);
04460    /* look for a viewer that is showing this surface and has this surface in focus*/
04461    for (i=0; i<SUMAg_N_SVv; ++i) {
04462       if (LocalHead) fprintf (SUMA_STDERR,"%s: Checking viewer %d.\n", FuncName, i);
04463       if (!SUMAg_SVv[i].isShaded && SUMAg_SVv[i].X->TOPLEVEL) {
04464          /* is this viewer showing SO ? */
04465          if (SUMA_isVisibleSO(&(SUMAg_SVv[i]), SUMAg_DOv, SO)) {
04466             if ((SUMAg_DOv[SUMAg_SVv[i].Focus_SO_ID].OP) == SO) {
04467                SUMA_UpdateXhairField(&(SUMAg_SVv[i]));
04468             }
04469          }
04470       }
04471    }
04472 
04473    SUMA_RETURN(YUP);
04474 }

03142 {
03143    static char FuncName[]={"SUMA_InitRangeTable"};
03144    char srange_min[50], srange_max[50], srange_minloc[50], srange_maxloc[50];
03145    SUMA_TABLE_FIELD *TF, *TFs;
03146    int i, j, i1D, fi, bi, ti;
03147    float range[2];
03148    NI_element *nel;
03149    SUMA_SCALE_TO_MAP_OPT *OptScl;
03150    SUMA_Boolean DoIs = NOPE, DoBs = NOPE, ColorizeBaby;
03151    SUMA_Boolean LocalHead = NOPE;
03152    
03153    SUMA_ENTRY;
03154 
03155    if (!SO->SurfCont) SUMA_RETURN(NOPE);
03156    TF = SO->SurfCont->RangeTable; 
03157    TFs = SO->SurfCont->SetRangeTable; 
03158    if (!TF || !TFs) SUMA_RETURN(NOPE);
03159    OptScl = SO->SurfCont->curColPlane->OptScl;
03160    fi = OptScl->find;
03161    ti = OptScl->tind;
03162    bi = OptScl->bind;
03163    ColorizeBaby = NOPE;
03164    
03165    switch (what) {
03166       case -1:
03167          DoIs = NOPE;
03168          DoBs = NOPE;
03169          break;
03170       case 2:
03171          DoIs = YUP;
03172          DoBs = YUP;
03173          break;
03174       case 0:
03175          DoIs = YUP;
03176          break;
03177       case 1:
03178          DoBs = YUP;
03179          break;
03180       default:
03181          SUMA_SL_Err("That's stupid Joe!");
03182          SUMA_RETURN(NOPE);
03183          break;
03184    }
03185    
03186    /* TF Range table Int*/
03187    SUMA_LH("Setting Int.");
03188    SUMA_RANGE_STRING(SO->SurfCont->curColPlane->dset_link, fi, srange_min, srange_max, srange_minloc, srange_maxloc, range); 
03189    SUMA_INSERT_CELL_STRING(TF, 1, 1, srange_min);/* min */
03190    SUMA_INSERT_CELL_STRING(TF, 1, 2, srange_minloc);/* minloc */
03191    SUMA_INSERT_CELL_STRING(TF, 1, 3, srange_max);/* max */
03192    SUMA_INSERT_CELL_STRING(TF, 1, 4, srange_maxloc);/* maxloc */
03193    /* TFs Range table Int*/
03194    if (DoIs) {
03195       if (SO->SurfCont->curColPlane->OptScl->AutoIntRange) { 
03196          if (!SO->SurfCont->curColPlane->ForceIntRange[0] && !SO->SurfCont->curColPlane->ForceIntRange[1]) {
03197             if (  OptScl->IntRange[0] != range[0] ||
03198                   OptScl->IntRange[1] != range[1] ) {
03199                ColorizeBaby = YUP;      
03200                OptScl->IntRange[0] = range[0]; OptScl->IntRange[1] = range[1]; 
03201             }
03202          } else {
03203             SUMA_LH("Using ForceIntRange");
03204             if (  OptScl->IntRange[0] != SO->SurfCont->curColPlane->ForceIntRange[0] ||
03205                   OptScl->IntRange[1] != SO->SurfCont->curColPlane->ForceIntRange[1] ) {
03206                ColorizeBaby = YUP;      
03207                OptScl->IntRange[0] = SO->SurfCont->curColPlane->ForceIntRange[0];
03208                OptScl->IntRange[1] = SO->SurfCont->curColPlane->ForceIntRange[1];
03209             }
03210          }
03211 
03212          /* enforce the SymIrange option */
03213          if (SO->SurfCont->curColPlane->SymIrange) {
03214             if (  OptScl->IntRange[1] != SUMA_LARG_ABS(OptScl->IntRange[0], OptScl->IntRange[1]) ||
03215                   OptScl->IntRange[0] != -OptScl->IntRange[1]) {
03216                ColorizeBaby = YUP;   
03217                OptScl->IntRange[1] = SUMA_LARG_ABS(OptScl->IntRange[0], OptScl->IntRange[1]);
03218                OptScl->IntRange[0] = -OptScl->IntRange[1];
03219             }
03220          }
03221 
03222          SUMA_INSERT_CELL_VALUE(TFs, 1, 1, OptScl->IntRange[0]);/* min */ 
03223          SUMA_INSERT_CELL_VALUE(TFs, 1, 2, OptScl->IntRange[1]);/* max */
03224       }else {
03225          /* Make sure viewer is showing same values as in OptScl */
03226          SUMA_LH("Imposing...");
03227          if (  OptScl->IntRange[0] != TFs->num_value[1*TFs->Ni+1] ||
03228                OptScl->IntRange[1] != TFs->num_value[2*TFs->Ni+1] ) {
03229             SUMA_INSERT_CELL_VALUE(TFs, 1, 1, OptScl->IntRange[0]);/* min */ 
03230             SUMA_INSERT_CELL_VALUE(TFs, 1, 2, OptScl->IntRange[1]);/* max */
03231          }
03232       }
03233    } 
03234    /* TF Range table Thr*/
03235    SUMA_LH("Setting Thr.");
03236    SUMA_RANGE_STRING(SO->SurfCont->curColPlane->dset_link, ti, srange_min, srange_max, srange_minloc, srange_maxloc, range); 
03237    SUMA_INSERT_CELL_STRING(TF, 2, 1, srange_min);/* min */
03238    SUMA_INSERT_CELL_STRING(TF, 2, 2, srange_minloc);/* minloc */
03239    SUMA_INSERT_CELL_STRING(TF, 2, 3, srange_max);/* max */
03240    SUMA_INSERT_CELL_STRING(TF, 2, 4, srange_maxloc);/* maxloc */
03241   
03242    /* TF Range table Brt*/
03243    SUMA_LH("Setting Brt.");
03244    SUMA_RANGE_STRING(SO->SurfCont->curColPlane->dset_link, bi, srange_min, srange_max, srange_minloc, srange_maxloc, range); 
03245    SUMA_INSERT_CELL_STRING(TF, 3, 1, srange_min);/* min */
03246    SUMA_INSERT_CELL_STRING(TF, 3, 2, srange_minloc);/* minloc */
03247    SUMA_INSERT_CELL_STRING(TF, 3, 3, srange_max);/* max */
03248    SUMA_INSERT_CELL_STRING(TF, 3, 4, srange_maxloc);/* maxloc */
03249    /* TFs Range table Brt*/
03250    if (DoBs) {
03251       if (SO->SurfCont->curColPlane->OptScl->AutoBrtRange) { 
03252          if (  OptScl->BrightRange[0] != range[0] ||
03253                OptScl->BrightRange[1] != range[1] ) {
03254             ColorizeBaby = YUP;      
03255             OptScl->BrightRange[0] = range[0]; OptScl->BrightRange[1] = range[1]; 
03256          }
03257          SUMA_INSERT_CELL_VALUE(TFs, 2, 1, OptScl->BrightRange[0]);/* min */
03258          SUMA_INSERT_CELL_VALUE(TFs, 2, 2, OptScl->BrightRange[1]);/* max */
03259          /* TFs Range table BrtMap*/
03260          SUMA_INSERT_CELL_VALUE(TFs, 3, 1, OptScl->BrightMap[0]);/* min */
03261          SUMA_INSERT_CELL_VALUE(TFs, 3, 2, OptScl->BrightMap[1]);/* max */
03262       } else {
03263          /* Make sure viewer is showing same values as in OptScl */
03264          if (  OptScl->BrightRange[0] != TFs->num_value[1*TFs->Ni+2] ||
03265                OptScl->BrightRange[1] != TFs->num_value[2*TFs->Ni+2] ||
03266                OptScl->BrightMap[0]   != TFs->num_value[1*TFs->Ni+3] ||
03267                OptScl->BrightMap[1]   != TFs->num_value[2*TFs->Ni+3]   ) {
03268             SUMA_INSERT_CELL_VALUE(TFs, 2, 1, OptScl->BrightRange[0]);/* min */
03269             SUMA_INSERT_CELL_VALUE(TFs, 2, 2, OptScl->BrightRange[1]);/* max */
03270             /* TFs Range table BrtMap*/
03271             SUMA_INSERT_CELL_VALUE(TFs, 3, 1, OptScl->BrightMap[0]);/* min */
03272             SUMA_INSERT_CELL_VALUE(TFs, 3, 2, OptScl->BrightMap[1]);/* max */
03273          }
03274       } 
03275    }
03276    
03277    /* TFs Range table CoordBias*/
03278    SUMA_INSERT_CELL_VALUE(TFs, 4, 1, OptScl->CoordBiasRange[0]);/* min */
03279    SUMA_INSERT_CELL_VALUE(TFs, 4, 2, OptScl->CoordBiasRange[1]);/* max */
03280    
03281    if (ColorizeBaby) {
03282       if (!SUMA_ColorizePlane (SO->SurfCont->curColPlane)) {
03283          SUMA_SLP_Err("Failed to colorize plane.\n");
03284          SUMA_RETURN(NOPE);
03285       }
03286    }
03287    SUMA_RETURN(YUP);
03288 }