/* ARGSUSED */
void AddGpList_Callback ( Widget w, long which, XtPointer call )
/************************************************************************
*
* Callback function of add group list.
*
* AddGpList_Callback ( W, which, CALL )
*
***********************************************************************/
{
/*--------------------------------------------------------------------*/
switch( which ) {
case 0: /* add to group list */
if ( get_group(w) ) {
XmListDeselectAllItems(gframe_listW);
XmTextSetString(group_nameW, "");
}
break;
case 1: /* add to group list and display */
if (get_group(w)) {
MpanelMode = 0;
SelectGroupNo = GroupNo;
GroupLoadFlag = 1;
XmListDeselectAllItems(gframe_listW);
XmTextSetString(group_nameW, "");
XtUnmanageChild(group_panel_toplevel);
load_group(GroupNo);
}
break;
}
}
void pp_display_filter_acct_cb(Widget w, XtPointer *call_data, XmAnyCallbackStruct *client_data)
{
int i;
XmString temp;
if (pp_main_poplist_shell == NULL)
{
create_pp_main_poplist_shell(product_packages_shell);
}
XmListDeleteAllItems (pp_main_poplist);
XmListDeselectAllItems (pp_main_poplist);
for (i = 0; i < num_pp_ext_ids_list; i++)
{
temp = XmStringCreateSimple (pp_ext_ids_list[i].description);
XmListAddItem (pp_main_poplist, temp, 0);
XmStringFree (temp);
}
/* Set the text field that will be populated when user selects
* a value from the list.
*/
XtVaSetValues (pp_main_poplist, XmNuserData, pp_filter_account_no_txt, NULL);
position_poplist (w,pp_main_poplist_shell);
XtManageChild (pp_main_poplist_form);
XtPopup (pp_main_poplist_shell, XtGrabNone);
}
/* ARGSUSED */
void model_confirm ( Widget w, long which, XtPointer call )
{
switch (which) {
case 0: /* Select */
if ( ( SelectFileNo == -1 ) |
( SelectModelNo == -1) )return;
strcpy(MetaFile,
ModelStr[SelectModelNo].file_fullnames[SelectFileNo - 1]);
XmListDeselectAllItems(model_listW);
if ( !MpanelMode )
clear_window();
load_meta();
break;
case 1: /* HELP */
NxmHelp_helpBtnCb( NULL, 8, NULL);
break;
case 2: /* CANCEL */
XtUnmanageChild(model_toplevel);
break;
}
}
void pp_add_package_cb(Widget w, XtPointer *call_data, XmAnyCallbackStruct *client_data)
{
char *today = NULL;
/* create screen */
if (pp_provision_shell == NULL)
{
create_pp_provision_shell (product_packages_shell);
create_ppp_confirm_shell (pp_provision_shell);
XtAddEventHandler(ppp_start_date_txt,KeyPressMask,False,
check_date,NULL);
}
/* erase the list */
XmListDeleteAllItems (ppp_prov_list);
XmListDeselectAllItems(ppp_prov_list);
gprov_new_package = 0;
today = get_todays_date();
XmTextSetString (ppp_start_date_txt, today);
XtFree (today);
XmTextSetString (ppp_packageid_txt,"");
/* display screen */
XtManageChild (pp_provision_form);
XtPopup (pp_provision_shell, XtGrabNone);
}
void ControlPanelGroupDialog::makeGroupList(int item)
{
XmString *xmstrings;
int items = this->panelManager->getGroupCount();
int i = -1;
if (items != 0)
{
xmstrings = new XmString[items];
for(i=0; i < items; i++)
{
xmstrings[i] =
XmStringCreateSimple((char*)this->panelManager->getPanelGroup(i+1, NULL));
}
}
else
{
items = 1;
xmstrings = new XmString[1];
xmstrings[0] = XmStringCreateSimple("(none)");
}
XtVaSetValues(this->list,
XmNitemCount, items,
XmNvisibleItemCount, items,
XmNitems, xmstrings,
NULL);
this->lastIndex = 0;
if(i < 0 OR item == 0)
{
XmTextSetString(this->text, NULL);
XtVaSetValues(this->changebtn, XmNsensitive, False, NULL);
XtVaSetValues(this->deletebtn, XmNsensitive, False, NULL);
XmListDeselectAllItems(this->list);
this->setToggles();
}
else
{
if(item > 0)
XmListSelectPos(this->list, item > items ? 0 : item, True);
else
{
char *name = XmTextGetString(this->text);
for(i=1; i<=items; i++)
if(EqualString(name,
(char*)this->panelManager->getPanelGroup(i,NULL)))
break;
XmListSelectPos(this->list, i, True);
XtFree(name); // AJ
}
}
for (i=0 ; i<items ; i++)
XmStringFree(xmstrings[i]);
delete xmstrings;
}
/***********************************************************************
* *
* Clear the selector columns. *
* *
***********************************************************************/
void clear_selector_columns(int option)
{
if (selector_dialog) {
if (option == 0 || option == 1) {
XmListSetPos(var1NtSList, 1);
XmListDeselectAllItems(var1NtSList);
XmListDeleteAllItems(var1NtSList);
XmListSelectPos(var1NtSList, 1, False);
}
if (option == 0 || option == 2) {
XmListSetPos(var2NtSList, 1);
XmListDeselectAllItems(var2NtSList);
XmListDeleteAllItems(var2NtSList);
}
}
}
/* ARGSUSED */
void Search_Callback ( Widget w, XtPointer clnt, XtPointer call )
/************************************************************************
*
* Callback function of Incremental selection apply button.
*
* Search_Callback(w, clnt, call)
*
***********************************************************************/
{
int inc[3], ii;
char text[20];
XmString comptext;
/*--------------------------------------------------------------------*/
if (SearchMode == 0) {
/*
* clear frame list.
*/
XmListDeselectAllItems(gframe_listW);
for ( ii = 0; ii < 3; ii++ ) {
get_text(Inc_textsW[ii], &text[0]);
inc[ii] = atoi(text);
}
/*
* check the number of frames.
*/
if( inc[2] > FrameNo ) {
add_IncNo();
inc[2] = FrameNo;
}
for ( ii = inc[0]-1; ii <= inc[2]-1; ii += inc[1] ) {
if ( ii >= 0 )
XmListSelectItem( gframe_listW, frameNameXm[ii], False);
}
}
else {
get_text(search_nameW, &text[0]);
if ( text[0] != (char)NULL ) {
comptext = XmStringCreate(text,
XmFONTLIST_DEFAULT_TAG);
for ( ii = 0; ii < FrameNo; ii++ ) {
if( XmStringHasSubstring(frameNameXm[ii], comptext)
== True )
XmListSelectItem( gframe_listW,
frameNameXm[ii], False);
}
XmStringFree( comptext );
}
}
}
/***********************************************************************
* *
* Copy selected items from the left list to the right list. *
* *
***********************************************************************/
static void copy_cb(Widget w, XtPointer cd, XmAnyCallbackStruct *cbs)
{
int icnt, pos, pcnt, *posl;
XmString *items;
if (XmListGetSelectedPos(var2NtSList, &posl, &pcnt)) {
pos = posl[pcnt-1] + 1;
XtFree((char *)posl);
} else
pos = 0;
XmListDeselectAllItems(var2NtSList);
if (w == exprNtSText) {
char *expr = XmTextGetString(w);
if (!strempty(expr)) {
XmString xms = XmStringCreateSimple(expr);
XmListAddItem(var2NtSList, xms, pos);
XmStringFree(xms);
}
XtFree(expr);
/*
* ugly... I don't want to show the scanner after hitting the
* KActivate in the text widget
*/
no_scan = True;
} else if (w == copyNtSButton) {
XtVaGetValues(var1NtSList, XmNselectedItemCount, &icnt,
XmNselectedItems, &items,
NULL);
XmListAddItems(var2NtSList, items, icnt, pos);
} else if (w == copyAllNtSButton) {
XtVaGetValues(var1NtSList, XmNitemCount, &icnt,
XmNitems, &items,
NULL);
clear_selector_columns(2);
XmListAddItems(var2NtSList, items, icnt, pos);
} else if (w == var1NtSList) {
XmListCallbackStruct *cbsl = (XmListCallbackStruct *) cbs;
if (cbsl->event->type == ButtonRelease)
XmListAddItem(var2NtSList, cbsl->item, pos);
}
XmListSelectPos(var2NtSList, pos, False);
}
/* ARGSUSED */
void ClearInc_Callback ( Widget w, XtPointer clnt, XtPointer call )
/************************************************************************
*
* Callback function of clear frame selection button.
*
* ClearInc_Callback ( W, DATA, CALL )
*
***********************************************************************/
{
XmListDeselectAllItems(gframe_listW);
}
// Select a process
static void SelectProcessCB(Widget w, XtPointer client_data,
XtPointer call_data)
{
XmListCallbackStruct *cbs = (XmListCallbackStruct *)call_data;
int pos = cbs->item_position;
if (pos == 1)
XmListDeselectAllItems(w); // Title selected
else
ListSetAndSelectPos(w, pos);
int pid = get_pid(w, client_data, call_data);
if (pid <= 0)
set_status("");
else
set_status("Process " + itostring(pid));
}
/*
** Set the contents of a list and compensate for various motif problems
** associated with this apparently bizarre act. (It might be worth
** further investigation to better understand why these workarounds
** are necessary).
*/
static void setListItems(Widget w, XmString *strings, int nStrings)
{
XmString *st1;
/* Motif doesn't reset the selection when items are changed */
XmListDeselectAllItems(w);
/* .. and sometimes leaves stray scroll bars if nothing is in the list */
if (nStrings == 0) {
XtVaSetValues(w, XmNitems, st1=StringTable(1, " "),
XmNitemCount, 1, XmNsensitive, False, 0);
FreeStringTable(st1);
} else {
XtVaSetValues(w, XmNitems, strings, XmNitemCount, nStrings,
XmNsensitive, True, 0);
}
}
/***********************************************************************
* *
* Reset the right list. *
* *
***********************************************************************/
static void reset_cb(Widget w, XtPointer cd, XmAnyCallbackStruct *cbs)
{
int icnt;
XmString *items;
if (w == deleteNtSButton) {
XtVaGetValues(var2NtSList, XmNselectedItemCount, &icnt,
XmNselectedItems, &items,
NULL);
XmListDeleteItems(var2NtSList, items, icnt);
} else if (w == resetNtSButton) {
XmListSetPos(var2NtSList, 1);
XmListDeselectAllItems(var2NtSList);
XmListDeleteAllItems(var2NtSList);
}
}
void populate_status_codes(Widget w, XtPointer client_data, XmAnyCallbackStruct *call_data)
{
if(eft_sel_shell == NULL)
create_eft_sel_shell(eft_shell);
XmListDeselectAllItems(eftsellist);
XmListDeleteAllItems(eftsellist);
XmListAddItems(eftsellist, eft_display_statuses_list, eft_num_display_statuses, 0);
position_poplist(w, eft_sel_shell);
XtManageChild(eft_sel_form);
XtPopup(eft_sel_shell, XtGrabNone);
XmProcessTraversal(eftsellist, XmTRAVERSE_CURRENT);
}
void set_scroller_list(Screen_Obj *sop, const char *string_list[],
int nlist)
{
#ifdef HAVE_MOTIF
int j;
XmString item;
/* first delete any old items */
XmListDeselectAllItems(sop->so_obj);
XmListDeleteAllItems(sop->so_obj);
for(j=0; j<nlist; j++)
{
item = XmStringCreateSimple((char *)string_list[j]);
XmListAddItem(sop->so_obj, item, 0);
XmStringFree(item);
}
XtManageChild(sop->so_obj);
#endif /* HAVE_MOTIF */
}
static void Reset(Widget w)
{
int status;
Widget list_w = XtNameToWidget(XtParent(w),"*interpreters");
static struct descriptor_d cli = {0, DTYPE_T, CLASS_D, 0};
static DESCRIPTOR(initial, "_I=0");
static DESCRIPTOR(clis, "(clis()[_I++]//\"\\0\")");
XtPointer user_data;
int nid;
String selections;
String selection;
int ctx = 0;
int first = 1;
XtVaGetValues(list_w, XmNuserData, &user_data, NULL);
nid = (intptr_t)user_data;
XmListDeselectAllItems(list_w);
XmListDeleteAllItems(list_w);
TdiExecute(&initial,&cli MDS_END_ARG);
while ((status=TdiExecute(&clis, &cli MDS_END_ARG)&1 && cli.length > 0 && strlen(cli.pointer) > 0))
{
XmString item;
item = XmStringCreateSimple(cli.pointer);
if (!XmListItemExists(list_w,item))
XmListAddItem(list_w,item,0);
XmStringFree(item);
}
selections = XmdsGetNidText(nid);
for (selection=strtok(selections,"\n");selection;selection=strtok(0,"\n"))
{
XmString item = XmStringCreateSimple(selection);
XmListSelectItem(list_w, item, 0);
if (first)
{
first = 0;
XmListSetItem(list_w, item);
}
XmStringFree(item);
}
XtFree(selections);
return;
}
static void
wspAllWsCB(
Widget buttonW,
WmScreenData *pSD,
XmToggleButtonCallbackStruct *xmTbcs )
{
PtrWsPresenceData pPres = &pSD->presence;
int wsnum;
XmString *pxmsSelected;
Arg args[5];
int n;
if (xmTbcs->reason == XmCR_VALUE_CHANGED)
{
if (xmTbcs->set)
{
pxmsSelected = (XmString *)
XtMalloc (pSD->numWorkspaces * sizeof (XmString));
for (wsnum = 0; wsnum < pSD->numWorkspaces; wsnum++)
{
pxmsSelected[wsnum] = pPres->ItemStrings[wsnum];
}
/* set the selected items */
n = 0;
XtSetArg (args[n], XmNselectedItems, pxmsSelected); n++;
XtSetArg (args[n], XmNselectedItemCount, pSD->numWorkspaces); n++;
XtSetValues (pPres->workspaceListW, args, n);
XtFree ((char *) pxmsSelected);
}
else
{
/* select current workspace */
XmListDeselectAllItems (pPres->workspaceListW);
XmListSelectPos (pPres->workspaceListW, pPres->currentWsItem, TRUE);
}
}
} /* END OF FUNCTION */
Widget RGISGrdPanel::Load (DBObjData *data)
{
int itemPosition = 0;
DBObjTable *layerTable = data->Table (DBrNLayers);
DBObjRecord *record;
XmString string;
XmListDeleteAllItems (LayerListWGT);
for (record = layerTable->First ();record != (DBObjRecord *) NULL;record = layerTable->Next ())
{
string = XmStringCreate (record->Name (),UICharSetNormal);
XmListAddItem (LayerListWGT, string, ++itemPosition);
XmStringFree (string);
}
XmListDeselectAllItems (LayerListWGT);
record = layerTable->Item ();
string = XmStringCreate (record->Name (),UICharSetNormal);
XmListSelectItem (LayerListWGT,string,False);
XmStringFree (string);
XtVaSetValues (LayerListWGT,XmNuserData, data, NULL);
return (Form ());
}
/* ARGSUSED */
void CtrB_Callback ( Widget w, long which, XtPointer call )
/************************************************************************
*
* Callback function of control buttons for group creation panel.
*
* ctrB_Callback ( w, which, call )
*
***********************************************************************/
{
int status = 0;
/*---------------------------------------------------------------------*/
switch (which) {
case 0: /* HELP */
NxmHelp_helpBtnCb( NULL, 7, NULL );
status = 0;
break;
case 1: /* CANCEL */
status = 1;
break;
default:
status = 1;
break;
}
if (status) {
XmListDeselectAllItems(gframe_listW);
XmTextSetString(group_nameW, "");
XtUnmanageChild(group_panel_toplevel);
}
}
void polygonformpop()
{
int ival, i, j;
XmListDeselectAllItems(pmatsellist);
for (j = 0; j < numlist; j++)
{
i = listmat[j];
if (active_mat[i])
XmListSelectPos(pmatsellist,j+1,FALSE);
}
ival = (int) (pexplodefact * 100.);
XmScaleSetValue(pexplode,ival);
XmToggleButtonGadgetSetState(pshade,polysflag,FALSE);
XmToggleButtonGadgetSetState(pline,linesflag,FALSE);
XmToggleButtonGadgetSetState(stipplebut,polystiplflag,FALSE);
shadedraw = polysflag;
linedraw = linesflag;
MyManageChild(polygonform);
}
/* ARGSUSED */
void LocalProduct_Callback ( Widget w, long which,
XmFileSelectionBoxCallbackStruct *call )
{
Widget list;
int itemc;
/*---------------------------------------------------------------------*/
switch( which ) {
case 0: /* ok callback (select) */
OpenModel = 1;
Select_File_Callback( local_toplevel,
NULL, call);
XtManageChild( group_select_toplevel );
break;
case 1: /* cancel callback (close) */
XtUnmanageChild( local_toplevel );
break;
case 2: /* apply callback ( update model ) */
list = XmFileSelectionBoxGetChild(
local_toplevel,
XmDIALOG_LIST);
XtVaGetValues(list,
XmNitemCount, &itemc,
NULL);
XmListDeselectAllItems(list);
XmFileSelectionDoSearch( local_toplevel,
call->mask);
XmListSetHorizPos(list, call->dir_length);
XtVaSetValues(list,
XmNitemCount, itemc,
NULL);
break;
}
}
void display_cmf_level_selection(Widget w)
{
int status;
int ret_code;
int i;
int account_no;
char external_id[49];
XmString temp;
if (pp_assoc_poplist_shell == NULL)
{
create_pp_assoc_poplist_shell(pp_provision_shell);
}
num_pp_elig_cmfs = 0;
XmListDeleteAllItems (pp_assoc_poplist);
XmListDeselectAllItems(pp_assoc_poplist);
dbfcmd(dbproc1, "exec pp_select_elig_cmf_component @comp_id = %d,",pp_prov_components[gassoc_selection].comp_id);
dbfcmd(dbproc1, " @hier_id = %d, ", ghierarchy_id);
dbfcmd(dbproc1, " @ext_id_type = %d ", gAcctExtIdType);
if(safe_dbexec(dbproc1,"SELECT_ELIGIBLE_CMFS", "select_eligible_cmfs"))
return;
while ((status = safe_dbresults (dbproc1, "SELECT_ELIGIBLE_CMFS", "select_eligible_cmfs")) != NO_MORE_RESULTS)
{
if (status == FAIL) return;
dbbind (dbproc1, 1, INTBIND, 0, &account_no);
dbbind (dbproc1, 2, NTBSTRINGBIND, 0, external_id);
while ((ret_code = dbnextrow(dbproc1)) != NO_MORE_ROWS)
{
if(ret_code == FAIL) return;
/* process results */
num_pp_elig_cmfs++;
pp_elig_cmfs = (ELIG_CMF_TYPE *) realloc (pp_elig_cmfs, num_pp_elig_cmfs * sizeof(ELIG_CMF_TYPE));
pp_elig_cmfs[num_pp_elig_cmfs - 1].account_no = account_no;
strcpy (pp_elig_cmfs[num_pp_elig_cmfs - 1].external_id,external_id);
}
}
for (i = 0; i < num_pp_elig_cmfs; i++)
{
temp = XmStringCreateSimple (pp_elig_cmfs[i].external_id);
XmListAddItem (pp_assoc_poplist, temp, 0);
XmStringFree (temp);
}
position_poplist (w,pp_assoc_poplist_shell);
XtManageChild (pp_assoc_poplist_form);
XtPopup (pp_assoc_poplist_shell, XtGrabNone);
}
void populate_emf_external_id_scrolled_list()
{
XmString temp;
RETCODE ret_code;
char display_string[300];
int status;
int lm;
char active_dt[9];
char inactive_dt[9];
char external_id_type[81];
char external_id[50];
char full_active_dt[33];
char full_inactive_dt[33];
int id_type;
/*get emf group list from db */
dbcmd(dbproc1, "select external_id,external_id_type,active_date,inactive_date,");
dbfcmd(dbproc1," convert(char(8),active_date,%d),", gdatefmt);
dbfcmd(dbproc1," convert(char(8),inactive_date,%d)", gdatefmt);
dbcmd(dbproc1," from CUSTOMER_ID_EQUIP_MAP ");
dbfcmd(dbproc1,"WHERE subscr_no = %d ",emf_active_subscr_no);
dbfcmd(dbproc1," and subscr_no_resets = %d ",emf_active_subscr_no_resets);
br_dbsqlexec(dbproc1);
if (Sybase_error)
{
dbcancel(dbproc1);
}
status = 0;
num_active_external_ids = 0;
free (active_external_ids);
active_external_ids = NULL;
XmListDeselectAllItems (emf_external_list);
XmListDeleteAllItems (emf_external_list);
while((ret_code = dbresults(dbproc1)) != NO_MORE_RESULTS)
{
if(ret_code == FAIL)
{
dbcancel(dbproc1);
break;
}
dbbind(dbproc1,1,NTBSTRINGBIND,0,external_id);
dbbind(dbproc1,2,INTBIND,0,&id_type);
dbbind(dbproc1,3,NTBSTRINGBIND,0,full_active_dt);
dbbind(dbproc1,4,NTBSTRINGBIND,0,full_inactive_dt);
dbbind(dbproc1,5,NTBSTRINGBIND,0,active_dt);
dbbind(dbproc1,6,NTBSTRINGBIND,0,inactive_dt);
while (dbnextrow(dbproc1) != NO_MORE_ROWS)
{
/* Found an entry. */
num_active_external_ids++;
active_external_ids = (EXTERNAL_ID_DATA_TYPE *)
realloc (active_external_ids,num_active_external_ids * sizeof (EXTERNAL_ID_DATA_TYPE));
strcpy (active_external_ids[num_active_external_ids - 1].external_id,external_id);
strcpy (active_external_ids[num_active_external_ids - 1].full_active_dt,full_active_dt);
strcpy (active_external_ids[num_active_external_ids - 1].active_dt,active_dt);
strcpy (active_external_ids[num_active_external_ids - 1].full_inactive_dt,full_inactive_dt);
strcpy (active_external_ids[num_active_external_ids - 1].inactive_dt,inactive_dt);
active_external_ids[num_active_external_ids - 1].external_id_type = id_type;
if(strlen(external_id) > EXTERNAL_ID_LEN-1) external_id[EXTERNAL_ID_LEN-1] = '\0';
strcpy (external_id_type,"");
for (lm = 0; lm < num_cmf_external_id_type_codes; lm++)
{
if (id_type == cmf_external_id_type_list[lm].db_code)
{
strcpy (external_id_type,cmf_external_id_type_list[lm].description);
break;
}
}
if(strlen(external_id_type) > 20) external_id_type[20] = '\0';
sprintf (display_string,"%-48.48s %-20.20s %-9s %-9s ",
external_id,external_id_type,active_dt,inactive_dt);
temp = XmStringCreateSimple (display_string);
XmListAddItem (emf_external_list, temp, 0); /* Add as last item in list */
XmStringFree (temp);
}
}
if(Sybase_error)
{
dbcancel(dbproc1);
}
}
/*************************************<->*************************************
*
* wspUpdateWorkspaceList (pPres)
*
*
* Description:
* -----------
* Updates the list widget containing all the workspaces.
* Sets the ones for this client.
*
* Inputs:
* ------
* pPres = ptr to presence dialog data
*
* Outputs:
* -------
* none
*
* Comments:
* ---------
******************************<->***********************************/
static void
wspUpdateWorkspaceList(
PtrWsPresenceData pPres )
{
int n;
XmString xmsTmp, *pxmsSelected;
WmScreenData *pSD;
Arg args[5];
int wsnum, numSelected;
/*
* Update the list of workspaces to -- one may have been
* renamed since the last time we were up.
*/
pSD = pPres->pCDforClient->pSD;
for (wsnum = 0; wsnum < pSD->numWorkspaces; wsnum++)
{
xmsTmp = XmStringCopy (pSD->pWS[wsnum].title);
if (!XmStringCompare (xmsTmp, pPres->ItemStrings[wsnum]))
{
/*
* Replace the string in our local list
*/
XmStringFree (pPres->ItemStrings[wsnum]);
pPres->ItemStrings[wsnum] = xmsTmp;
/*
* Replace the item in the scrolled list.
*/
XmListDeletePos (pPres->workspaceListW, 1+wsnum);
XmListAddItem (pPres->workspaceListW, xmsTmp, 1+wsnum);
}
else
{
XmStringFree (xmsTmp);
}
}
/*
* Highlight the workspaces this client resides in
*/
XmListDeselectAllItems (pPres->workspaceListW);
pxmsSelected = (XmString *)
XtMalloc (pPres->pCDforClient->pSD->numWorkspaces * sizeof (XmString));
numSelected = 0;
for (wsnum = 0; wsnum < pPres->pCDforClient->pSD->numWorkspaces; wsnum++)
{
if (ClientInWorkspace (&pPres->pCDforClient->pSD->pWS[wsnum],
pPres->pCDforClient))
{
pxmsSelected[numSelected++] = pPres->ItemStrings[wsnum];
pPres->ItemSelected[wsnum] = True;
}
else
{
pPres->ItemSelected[wsnum] = False;
pPres->pCDforClient->putInAll = False;
}
if (pPres->pCDforClient->pSD->pActiveWS->id ==
pPres->pCDforClient->pSD->pWS[wsnum].id)
{
/* save item number of current workspace */
pPres->currentWsItem = 1+wsnum;
}
}
/* set the selected items */
n = 0;
XtSetArg (args[n], XmNselectedItems, pxmsSelected); n++;
XtSetArg (args[n], XmNselectedItemCount, numSelected); n++;
XtSetValues (pPres->workspaceListW, args, n);
/* set state of all workspaces button */
n = 0;
XtSetArg (args[n], XmNset, pPres->pCDforClient->putInAll); n++;
XtSetValues (pPres->allWsW, args, n);
/* set name of window we're popped up for */
wspSetWindowName (pPres);
XtFree ((char *) pxmsSelected);
} /* END OF FUNCTION */
static int motListSetValueAttrib(Ihandle* ih, const char* value)
{
if (ih->data->has_editbox)
{
Widget cbedit;
XtVaGetValues(ih->handle, XmNtextField, &cbedit, NULL);
if (!value) value = "";
iupAttribSet(ih, "_IUPMOT_DISABLE_TEXT_CB", "1"); /* disable callbacks */
iupmotTextSetString(cbedit, value);
iupAttribSet(ih, "_IUPMOT_DISABLE_TEXT_CB", NULL);
}
else
{
if (ih->data->is_dropdown)
{
int pos;
if (iupStrToInt(value, &pos)==1)
{
XtRemoveCallback(ih->handle, XmNselectionCallback, (XtCallbackProc)motListComboBoxSelectionCallback, (XtPointer)ih);
XtVaSetValues(ih->handle, XmNselectedPosition, pos-1, NULL); /* IUP starts at 1 */
iupAttribSetInt(ih, "_IUPLIST_OLDVALUE", pos);
XtAddCallback(ih->handle, XmNselectionCallback, (XtCallbackProc)motListComboBoxSelectionCallback, (XtPointer)ih);
}
}
else
{
if (!ih->data->is_multiple)
{
int pos;
if (iupStrToInt(value, &pos)==1)
{
XmListSelectPos(ih->handle, pos, FALSE); /* XmListSelectPos starts at 1 */
iupAttribSetInt(ih, "_IUPLIST_OLDVALUE", pos);
}
else
{
XmListDeselectAllItems(ih->handle);
iupAttribSet(ih, "_IUPLIST_OLDVALUE", NULL);
}
}
else
{
/* User has changed a multiple selection on a simple list. */
int i, count, len;
/* Clear all selections */
XmListDeselectAllItems(ih->handle);
if (!value)
{
iupAttribSet(ih, "_IUPLIST_OLDVALUE", NULL);
return 0;
}
XtVaGetValues(ih->handle, XmNitemCount, &count, NULL);
len = strlen(value);
if (len < count)
count = len;
XtVaSetValues(ih->handle, XmNselectionPolicy, XmMULTIPLE_SELECT, NULL);
/* update selection list */
for (i = 0; i<count; i++)
{
if (value[i]=='+')
XmListSelectPos(ih->handle, i+1, False); /* XmListSelectPos starts at 1 */
}
XtVaSetValues(ih->handle, XmNselectionPolicy, XmEXTENDED_SELECT,
XmNselectionMode, XmNORMAL_MODE, NULL); /* must also restore this */
iupAttribSetStr(ih, "_IUPLIST_OLDVALUE", value);
}
}
}
return 0;
}
void pp_get_pkg_picked(Widget w, XtPointer *client_data, XmListCallbackStruct *call_data)
{
int selection;
int component_id;
char component_desc[81];
int max_allowed;
int min_reqd;
int comp_level;
int status;
int ret_code;
char *start_date = NULL;
int valid_date_found = 0;
selection = call_data->item_position - 1;
gprov_new_package = pp_elig_pkgs[selection].db_code;
XmTextSetString (ppp_packageid_txt, pp_elig_pkgs[selection].description);
valid_date_found = validate_date (ppp_start_date_txt,&start_date);
if (!valid_date_found)
{
return;
}
if (strcmp(start_date,"") == 0)
{
post_dialog (pp_provision_shell,XmDIALOG_ERROR,"Start Date cannot be blank.");
return;
}
XtUnmanageChild (pp_poplist_form);
XtPopdown (pp_poplist_shell);
/* now got get the components for this package */
num_pp_avail_components = 0;
show_busy_cursor(pp_provision_shell, TRUE);
XmListDeleteAllItems (ppp_prov_list);
XmListDeselectAllItems (ppp_prov_list);
dbfcmd(dbproc1, "exec pp_select_avail_components @pkg_id = %d,",gprov_new_package);
dbfcmd(dbproc1, " @lang_code = %d, ", gGUIlanguage);
dbfcmd(dbproc1, " @input_date = '%s' ", start_date);
if(safe_dbexec(dbproc1,"SELECT_ELIGIBLE_COMPONENTS", "select_eligible_comps"))
return;
while ((status = safe_dbresults (dbproc1, "SELECT_ELIGIBLE_COMPONENTS", "select_eligible_comps")) != NO_MORE_RESULTS)
{
if (status == FAIL) return;
dbbind (dbproc1, 1, INTBIND, 0, &component_id);
dbbind (dbproc1, 2, NTBSTRINGBIND, 0, component_desc);
dbbind (dbproc1, 3, INTBIND, 0, &min_reqd);
dbbind (dbproc1, 4, INTBIND, 0, &max_allowed);
dbbind (dbproc1, 5, INTBIND, 0, &comp_level);
while ((ret_code = dbnextrow(dbproc1)) != NO_MORE_ROWS)
{
if(ret_code == FAIL) return;
/* process results */
num_pp_avail_components++;
pp_avail_components = (COMPONENT_PROV_TYPE *) realloc (pp_avail_components, num_pp_avail_components * sizeof(COMPONENT_PROV_TYPE));
pp_avail_components[num_pp_avail_components - 1].comp_id = component_id;
pp_avail_components[num_pp_avail_components - 1].level_code = comp_level;
pp_avail_components[num_pp_avail_components - 1].min_reqd = min_reqd;
pp_avail_components[num_pp_avail_components - 1].max_allowed = max_allowed;
strcpy (pp_avail_components[num_pp_avail_components - 1].comp_text,component_desc);
}
}
pp_build_prov_comp_list();
pp_display_avail_components();
show_busy_cursor(pp_provision_shell, FALSE);
}
/***********************************************************************
* *
* Show (manage) the column selector dialog. *
* *
***********************************************************************/
void show_columnSelector(Widget w, XtPointer cd,
XmAnyCallbackStruct *call_data)
{
MenuCbStruct *scan_button;
int icnt;
XmString *items;
if (!selector_dialog) {
selector_dialog = create_columnSelection(w);
/*
* Install callbacks
*/
scan_button = make_menuStruct(w, selector_dialog);
InstallMwmCloseCallback(XtParent(selector_dialog),
(XtCallbackProc)cancel_cb,
(XtPointer)scan_button);
/*
* Install event handler on EnterNotify events
*/
XtAddEventHandler(XtParent(selector_dialog), EnterWindowMask, False,
(XtEventHandler)enter_ntuple_viewer, NULL);
XtAddCallback(exprNtSText, XmNactivateCallback,
(XtCallbackProc)copy_cb, NULL);
XtAddCallback(copyNtSButton, XmNactivateCallback,
(XtCallbackProc)copy_cb, NULL);
XtAddCallback(copyAllNtSButton, XmNactivateCallback,
(XtCallbackProc)copy_cb, NULL);
XtAddCallback(var1NtSList, XmNdefaultActionCallback,
(XtCallbackProc)copy_cb, NULL);
XtAddCallback(scanNtSButton, XmNactivateCallback,
(XtCallbackProc)show_ntupleScanner, NULL);
XtAddCallback(deleteNtSButton, XmNactivateCallback,
(XtCallbackProc)reset_cb, NULL);
XtAddCallback(resetNtSButton, XmNactivateCallback,
(XtCallbackProc)reset_cb, NULL);
XtAddCallback(cancelNtSButton, XmNactivateCallback,
(XtCallbackProc)cancel_cb, scan_button);
/* store MenuCbSruct in userData */
XtVaSetValues(selector_dialog, XmNuserData, scan_button, NULL);
}
/* clear left list */
XmListSetPos(var1NtSList, 1);
XmListDeselectAllItems(var1NtSList);
XmListDeleteAllItems(var1NtSList);
/*
* Copy var list from ntupleBrowser to left list of columnSelection
* dialog. In case there are no variables in the ntupleBrowser return.
*/
XtVaGetValues(varNtList, XmNitemCount, &icnt,
XmNitems, &items, NULL);
if (!icnt) return;
XmListAddItems(var1NtSList, items, icnt, 1);
XmListSelectPos(var1NtSList, 1, False);
/* Make scan button on ntupleBrowser insensitive and popup dialog */
XtSetSensitive(w, False);
XtManageChild(selector_dialog);
}
static void reset_pops_dialog(Widget w, KLUDGE *shit, XmAnyCallbackStruct *cb)
{
if (shit && shit->w) XmListDeselectAllItems(shit->w);
}
void pp_display_avail_components()
{
typedef struct
{
char item [200];
int total;
} DUPLICATES;
DUPLICATES *Duplicates = NULL; /* List of duplicates assigned */
DUPLICATES TempDup;
XmString temp;
char TempString[10];
int i, n, NumDuplicates;
char display_string [200];
char trunc_external_id[49];
char trunc_comp_text[81];
XmListDeleteAllItems (ppp_prov_list);
XmListDeselectAllItems (ppp_prov_list);
show_busy_cursor(pp_provision_shell,TRUE);
n = 0;
NumDuplicates = 0;
/* set up and display each item */
for (i = 0; i < num_pp_prov_components; i++)
{
strcpy (trunc_comp_text, pp_prov_components[i].comp_text);
if (strlen(trunc_comp_text) > 40) trunc_comp_text[40] = '\0';
strcpy (trunc_external_id, pp_prov_components[i].external_id);
if (strlen(trunc_external_id) > 20) trunc_external_id[20] = '\0';
sprintf (display_string, "%-10d %-40s %-20s",
pp_prov_components[i].comp_id,
trunc_comp_text, trunc_external_id);
if(pp_prov_components[i].is_reqd)
{
strcat (display_string," Y ");
}
else
{
strcat (display_string," N ");
}
/* Add all the items to the Duplicates list - for duplicates counter (** MR **) */
if (NumDuplicates == 0) /* No duplicates */
{
NumDuplicates++;
sprintf (TempDup.item, "%s", display_string);
TempDup.total = 1;
if (! (Duplicates = (DUPLICATES *)
realloc(Duplicates, sizeof(DUPLICATES) * (NumDuplicates + 1))))
{
printf ("Could not perform reallac for list of Duplicates. Exiting");
exit (1);
}
Duplicates[0] = TempDup;
}
else
{
/* go through the list to see if the element is already there */
for (n = 0; n < NumDuplicates; n++)
{
if (strcmp (Duplicates[n].item, display_string) == 0)
{
Duplicates[n].total++;
break;
}
}
if (n == NumDuplicates) /* Item not in list - add */
{
NumDuplicates++;
sprintf (TempDup.item, "%s", display_string);
TempDup.total = 1;
if (! (Duplicates = (DUPLICATES *)
realloc(Duplicates, sizeof(DUPLICATES) * (NumDuplicates + 1))))
{
printf ("Could not perform reallac for list of Duplicates. Exiting");
exit (1);
}
Duplicates[NumDuplicates-1] = TempDup;
}
}
}
/* Now add all the items into the list box */
for (n=0; n < NumDuplicates; n++)
{
sprintf (TempString, " %d", Duplicates[n].total);
strcat (Duplicates[n].item, TempString);
temp = XmStringCreateSimple (Duplicates[n].item);
XmListAddItem (ppp_prov_list,temp,0);
XmStringFree (temp);
}
show_busy_cursor(pp_provision_shell,FALSE);
}
/* ARGSUSED */
void dslw_groupCb ( Widget w, XtPointer clnt, XtPointer call )
/************************************************************************
* dslw_groupCb *
* *
* This functions display the group products. It is the callback for *
* group list. *
* *
* void dslw_groupCb(w, clnt, call) *
* *
* Input parameters: *
* w Widget *
* clnt XtPointer *
* call XtPointer *
* *
** *
* Log: *
* L. Williams/EAI 06/95 *
* C. Lin/EAI 10/95 add comments *
* J. Wu/GSC 05/01 free XmStrings *
* T. Piper/GSC 6/01 Freed xmstr *
* T. Piper/SAIC 10/06 Replaced XmStringGetLtoR with *
* XmStringUnparse *
***********************************************************************/
{
struct guid_grp *group_ptr;
XmListCallbackStruct *cbs = (XmListCallbackStruct *) call;
XmString *xmstr;
char str[100];
int ii;
int prdcnt, nselect;
char *selected_item;
/*---------------------------------------------------------------------*/
/*
* return when no selection was made
*/
XtVaGetValues(w,
XmNselectedItemCount, &nselect,
NULL);
if ( nselect == 0 )
return;
XmListDeselectAllItems(_prodlistW);
/*
* get the selected group name
*/
selected_item = XmStringUnparse (cbs->item, NULL, XmCHARSET_TEXT,
XmCHARSET_TEXT, NULL, 0, XmOUTPUT_ALL);
/*
* Search the link list for the selected item
*/
group_ptr = guid_grp_head;
while ( group_ptr ) {
if (strcmp(group_ptr->grpname, selected_item) == 0) {
usrSelect.group = group_ptr;
break;
}
else
group_ptr = group_ptr->nextgrp;
}
/*
* If products exist move product name into array.
*/
if (group_ptr->nprod) {
xmstr = (XmString *) XtMalloc(sizeof(XmString) * (size_t)group_ptr->nprod);
for (ii=0; ii<group_ptr->nprod; ii++) {
if ( group_ptr->prod[ii].index == -2 ) {
/*
* the selected product is not available
*/
sprintf(str, "%s *", group_ptr->prod[ii].prdname);
xmstr[ii] = XmStringCreateLocalized(str);
}
else
xmstr[ii] = XmStringCreateLocalized(group_ptr->prod[ii].prdname);
}
}
else {
/*
* No products exist.
*/
xmstr = (XmString *) XtMalloc (sizeof(XmString));
xmstr[0] = XmStringCreateLocalized("No products available");
}
XtFree( selected_item );
/*
* display "No products available"
*/
prdcnt=group_ptr->nprod;
if (!prdcnt) ++prdcnt;
XtVaSetValues(_prodlistW,
XmNitems, xmstr,
XmNitemCount, prdcnt,
NULL);
for (ii=0; ii<prdcnt; ii++) {
XmStringFree( xmstr[ii] );
}
XtFree((XtPointer)xmstr);
}
void pp_display_prov_pkg_cb(Widget w, XtPointer *call_data, XmAnyCallbackStruct *client_data)
{
int package_id;
char package_desc[100];
int i;
int status;
int ret_code;
XmString temp;
int valid_date_found = 0;
char *start_date = NULL;
if (pp_poplist_shell == NULL)
{
create_pp_poplist_shell(pp_provision_shell);
}
valid_date_found = validate_date (ppp_start_date_txt,&start_date);
if (!valid_date_found)
{
return;
}
if (strcmp(start_date,"") == 0)
{
post_dialog (pp_provision_shell,XmDIALOG_ERROR,"Start Date cannot be blank.");
return;
}
num_pp_elig_pkgs = 0;
XmListDeselectAllItems (pp_poplist);
XmListDeleteAllItems (pp_poplist);
dbfcmd(dbproc1, "exec pp_select_eligible_pkgs @account_no = %d,",gaccount_no);
dbfcmd(dbproc1, " @lang_code = %d, ", gGUIlanguage);
dbfcmd(dbproc1, " @input_date = '%s' ", start_date);
if(safe_dbexec(dbproc1,"SELECT_ELIGIBLE_PKGS", "select_eligible_pkgs"))
return;
while ((status = safe_dbresults (dbproc1, "SELECT_ELIGIBLE_PKGS", "select_eligible_pkgs")) != NO_MORE_RESULTS)
{
if (status == FAIL) return;
dbbind (dbproc1, 1, INTBIND, 0, &package_id);
dbbind (dbproc1, 2, NTBSTRINGBIND, 0, package_desc);
while ((ret_code = dbnextrow(dbproc1)) != NO_MORE_ROWS)
{
if(ret_code == FAIL) return;
/* process results */
num_pp_elig_pkgs++;
pp_elig_pkgs = (DB_POPLIST_TYPE *) realloc (pp_elig_pkgs, num_pp_elig_pkgs * sizeof(DB_POPLIST_TYPE));
pp_elig_pkgs[num_pp_elig_pkgs - 1].db_code = package_id;
strcpy (pp_elig_pkgs[num_pp_elig_pkgs - 1].description,package_desc);
}
}
for (i = 0; i < num_pp_elig_pkgs; i++)
{
temp = XmStringCreateSimple (pp_elig_pkgs[i].description);
XmListAddItem (pp_poplist, temp, 0);
XmStringFree (temp);
}
position_poplist (w,pp_poplist_shell);
XtManageChild (pp_poplist_form);
XtPopup (pp_poplist_shell, XtGrabNone);
}
