bool CChangeCPPFieldPermissionsAction::ActionPerformed(symbolPtr* pSym) {
CImpactAction::ActionPerformed(pSym);
Boolean bStatic = XmToggleButtonGadgetGetState(m_staticInd);
string szStatic = (bStatic?"1":"0");
Boolean bConst = XmToggleButtonGadgetGetState(m_constInd);
string szConst = (bConst?"1":"0");
char strPerm[10];
sprintf(strPerm,"%d", m_nPermission);
string command = "Impact:ChangeCPPFieldDeclaration " + prepareQuery(CEntityInfo::etag(pSym)) + " " + strPerm + " " + szConst + " " + szStatic;
string szDesc = GetName()+" to ";
if(bConst) szDesc += " const";
if(bStatic) szDesc += " static";
if(m_nPermission==PUBLIC) szDesc += " public";
else if(m_nPermission==PRIVATE) szDesc += " private";
else if(m_nPermission==PROTECTED) szDesc += " protected";
SetDescription(szDesc);
string results;
CEntityInfo::exec(command,results);
parseResult(results);
return true;
}
bool CChangeJavaFunctionPermissionsAction::ActionPerformed(symbolPtr* pSym) {
CImpactAction::ActionPerformed(pSym);
Boolean bAbstract = XmToggleButtonGadgetGetState(m_abstractInd);
string szAbstract = (bAbstract?"1":"0");
Boolean bStatic = XmToggleButtonGadgetGetState(m_staticInd);
string szStatic = (bStatic?"1":"0");
Boolean bFinal = XmToggleButtonGadgetGetState(m_finalInd);
string szFinal = (bFinal?"1":"0");
Boolean bNative = XmToggleButtonGadgetGetState(m_nativeInd);
string szNative = (bNative?"1":"0");
char strPerm[10];
sprintf(strPerm,"%d", m_nPermission);
string command = "Impact:ChangeJavaFunctionDeclaration " + prepareQuery(CEntityInfo::etag(pSym)) +
" " + strPerm + " " + szAbstract + " " + szFinal + " " + szStatic + " " + szNative;
string szDesc = GetName()+" to ";
if(bAbstract) szDesc += " abstract";
if(bFinal) szDesc += " final";
if(bStatic) szDesc += " static";
if(bNative) szDesc += " native";
if(m_nPermission==PUBLIC) szDesc += " public";
else if(m_nPermission==PRIVATE) szDesc += " private";
else if(m_nPermission==PROTECTED) szDesc += " protected";
SetDescription(szDesc);
string results;
CEntityInfo::exec(command,results);
parseResult(results);
return true;
}
void stackmen_buta(Widget iw_temp, XtPointer data, XtPointer call_data)
{
char *string = NULL;
int vval;
/* Get the state of toggle */
all = XmToggleButtonGadgetGetState(iw_all);
single = XmToggleButtonGadgetGetState(iw_single);
section = XmToggleButtonGadgetGetState(iw_section);
/* No question for this in this menu, so default it to FALSE */
montaverage = FALSE;
/* Get the num for stkgo and stkend */
if (single)
{
string = XmTextGetString(iw_single1);
/* Find file numbers wanted */
if (sscanf(string,"%d",&vval) <= 0 || vval < 0)
{ /* Can not interpret the image number */
spout("*** Can not parse image number! ");
if (string) XtFree (string); return;
}
stkgo = vval;
stkend = vval;
}
else if (section)
{
/* Get stkgo */
string = XmTextGetString(iw_stkgo);
if (sscanf(string,"%d",&vval) <= 0 || vval < 0)
{ /* Can not interpret vval */
spout("*** Can not parse starting image number! ");
if (string) XtFree (string); return;
}
else
stkgo = vval;
/* Get stkend */
string = XmTextGetString(iw_stkend);
if (sscanf(string,"%d",&vval) <= 0 || vval < 0)
{ /* Can not interpret vval */
spout("*** Can not parse ending image number ending! ");
if (string) XtFree (string); return;
}
else
stkend = vval;
if (string) XtFree (string);
}
/* Remove the stack menu */
XtUnmanageChild(iw_stackmen);
expos_cb(NULL,NULL,NULL);
/* Display the montage, imagego set in imagemen */
stackdis(imagego,imageend);
}
static void
SetFileSelValues(
I18nEnv *env
)
{
char *hostname;
Cardinal i;
XtArgVal n;
Widget *im_tog;
/* The hostname value is stored in the ImsSel structure. */
env->file_sel->hostname = XtNewString(env->ims_sel->host_name);
/* Get the selected IM from the selected Toggle button */
XtVaGetValues(i18n.inputMethodRC, XmNchildren, &im_tog,
XmNnumChildren, &n, NULL);
if (n) {
for (i=0; i<n; i++) {
if (XmToggleButtonGadgetGetState(im_tog[i]) == TRUE) {
XtVaGetValues(im_tog[i], XmNuserData,
&(env->file_sel->im_name),
NULL);
break;
}
}
}
else
env->file_sel->im_name = NULL;
/* Get the start mode from the askAtLoginTG state */
if (XmToggleButtonGadgetGetState(i18n.askAtLoginTG) == TRUE)
env->file_sel->start_mode = 0;
else
env->file_sel->start_mode = 1;
}
void UI2DView::SetUserToggleMode(DBInt visible) {
if (visible) XtManageChild(UserToggle);
else {
if (XmToggleButtonGadgetGetState(UserToggle))
XmToggleButtonGadgetSetState(ZoomToggle, true, true);
XtUnmanageChild(UserToggle);
}
}
static void
okWarnCB(
Widget w,
XtPointer client_data,
XtPointer call_data )
{
dtwm.origKeyboardFocusPolicy = XmToggleButtonGadgetGetState (dtwm.explicitTG);
dtwm.origFocusAutoRaise = XmToggleButtonGadgetGetState (dtwm.autoRaiseTG);
dtwm.origSecStack = !XmToggleButtonGadgetGetState (dtwm.secStackTG);
dtwm.origMoveOpaque = XmToggleButtonGadgetGetState (dtwm.moveOpaqueTG);
dtwm.origUseIconBox = XmToggleButtonGadgetGetState (dtwm.iconBoxTG);
/* write out resources to xrdb */
_DtAddToResource(style.display, dtwmRes);
/* force the workspace manager to restart */
_DtWmRestartNoConfirm(style.display, style.root);
}
static void
cb_open_new_window(Widget w, XtPointer client_data, XtPointer call_data)
{
UNUSED(client_data);
UNUSED(call_data);
if (XmToggleButtonGadgetGetState(w))
resource.filesel_open_new_window = True;
else
resource.filesel_open_new_window = False;
store_preference(NULL, "fileselOpenNewWindow", "%d", resource.filesel_open_new_window);
}
void imoptmen_buta(Widget iw_temp, void * data, void * call_data)
{
/* names_height: pixel height of the filename */
if( (names = XmToggleButtonGadgetGetState(iw_names)) )
names_height = 12;
else
names_height = 0;
keepxy = XmToggleButtonGadgetGetState(iw_keepxy);
newline = XmToggleButtonGadgetGetState(iw_newline);
nuscrn = XmToggleButtonGadgetGetState(iw_nuscrn);
listfi = XmToggleButtonGadgetGetState(iw_listfi);
movie = XmToggleButtonGadgetGetState(iw_movieo);
if (strtoint(iw_marlef,"left margin",&marlef) == FALSE) return;
if (strtoint(iw_martop,"top margin", &martop) == FALSE) return;
if (strtoint(iw_marx, "x margin", &marx) == FALSE) return;
if (strtoint(iw_mary, "y margin", &mary) == FALSE) return;
if (strtoint(iw_iskip, "reduction", &iskip) == FALSE) return;
XtUnmanageChild(iw_imoptmen);
}
void
RespondLangCB( Widget w, XtPointer client, XtPointer call)
{
XtSetArg(argt[0], XmNset, True);
XtSetValues(w, argt, 1);
#ifdef VG_TRACE
vg_TRACE_EXECUTION("main: entered RespondLangCB ...");
#endif /* VG_TRACE */
if (amChooser) {
/** this is probably not the ideal way to do this **/
/** but it does work ok. **/
/** notice the related code in chooser.c at the **/
/** beginning of main. **/
char buff[128];
if (XmToggleButtonGadgetGetState(w)) {
strcpy(buff, "LANG=");
strcat(buff, client);
putenv(buff);
execv(orig_argv[0], orig_argv);
}
} else {
char buf[REQUEST_LIM_MAXLEN];
ResponseLang *r = (ResponseLang *)buf;
char *p;
r->hdr.opcode = REQUEST_OP_LANG;
r->hdr.reserved = 0;
r->offLang = sizeof(*r);
p = ((char *)(r)) + r->offLang;
strcpy(p, XmToggleButtonGadgetGetState(w) ? client : "default");
r->hdr.length = sizeof(*r) + strlen(p) + 1;
TellRequester(buf, (size_t) r->hdr.length);
CleanupAndExit(NULL, NOTIFY_LANG_CHANGE);
}
}
void moviemen_buta(Widget iw_t, void * data, void * call_data)
{
/* get delay */
XmScaleGetValue(iw_delay,&moviedelay);
/* get moviemagni (magnification counter) */
XmScaleGetValue(iw_magni,&moviemagni);
/* get moviecycl (runb cycles counter) */
XmScaleGetValue(iw_cycl,&moviecycl);
/* get twoway toggle */
twoway = XmToggleButtonGadgetGetState(iw_twoway);
XtUnmanageChild(iw_moviemen);
/* start movie going */
wid_movie();
} /* end of moviemen_buta */
/*
* ------------------------------------------------------------------------
* Name: PdmJobBoxSetAttr
*
* Description:
*
* Return value:
*
* None.
*
*/
static void
PdmJobBoxSetAttr(PdmSetupBox* me, PdmXp* pdm_xp)
{
PdmJobBoxData* data = (PdmJobBoxData*)me->subclass_data;
if(data->job_options_supported)
{
String value;
XtVaGetValues(data->job_options_text, XmNvalue, &value, NULL);
#if 0 && defined(PRINTING_SUPPORTED)
PdmXpSetStringValue(pdm_xp, XPJobAttr,
pdmoid_att_xp_spooler_command_options, value);
#endif /* PRINTING_SUPPORTED */
XtFree(value);
}
if(data->job_name_supported)
{
String value;
XtVaGetValues(data->job_name_text, XmNvalue, &value, NULL);
#if 0 && defined(PRINTING_SUPPORTED)
PdmXpSetStringValue(pdm_xp, XPJobAttr, pdmoid_att_job_name, value);
#endif /* PRINTING_SUPPORTED */
XtFree(value);
}
if(data->notification_profile_supported)
{
Boolean set;
set = XmToggleButtonGadgetGetState(data->notify_toggle);
#if 0 && defined(PRINTING_SUPPORTED)
PdmXpSetStringValue(pdm_xp, XPJobAttr,
pdmoid_att_notification_profile,
PdmOidNotifyString(set
? PDMOID_NOTIFY_EMAIL
: PDMOID_NOTIFY_NONE));
#endif /* PRINTING_SUPPORTED */
}
}
/***********************************************************************
* *
* Send mail. *
* *
***********************************************************************/
static void send_mail(Widget w, XtPointer cd, XmAnyCallbackStruct *cbs)
{
char *name, *inst, *phone, *email, *mess, mode;
mode = XmToggleButtonGadgetGetState(bugMailToggle) ? 'B' : 'C';
name = XmTextGetString(userMailText);
inst = XmTextGetString(instituteMailText);
phone = XmTextGetString(phoneMailText);
email = XmTextGetString(emailMailText);
mess = XmTextGetString(bugMailText);
if (br_mail_motif(mode, name, inst, phone, email, mess))
km_warn_user(mailDialog, "Error sending mail...", "");
else
UxPopdownInterface(mailDialog);
XtFree(name);
XtFree(inst);
XtFree(phone);
XtFree(email);
XtFree(mess);
}
/*+++++++++++++++++++++++++++++++++++++++*/
static void
ButtonCB(
Widget w,
XtPointer client_data,
XtPointer call_data )
{
int n;
Arg args[MAX_ARGS];
char *resPtr;
Boolean state;
Boolean changeFlag = 0;
DtDialogBoxCallbackStruct *cb = (DtDialogBoxCallbackStruct *) call_data;
switch (cb->button_position)
{
case OK_BUTTON:
XtUnmanageChild (w);
/* create the Dtwm resource specs for xrdb */
state = XmToggleButtonGadgetGetState (dtwm.explicitTG);
if ( state != dtwm.origKeyboardFocusPolicy)
{
sprintf(dtwmRes, "Dtwm.keyboardFocusPolicy: %s\n",
XmToggleButtonGadgetGetState (dtwm.pointerTG)
? POINTER_STR : EXPLICIT_STR);
changeFlag = 1;
}
/* write out FocusAutoRaise if toggle has changed or if
* KeyboardFocusPolicy has changed. FAR default value is
* based off of KFP so must set explicitly or visible toggle
* will be inacurate */
state = XmToggleButtonGadgetGetState (dtwm.autoRaiseTG);
if (state != dtwm.origFocusAutoRaise || changeFlag)
{
sprintf(dtwmRes+strlen(dtwmRes), "Dtwm*focusAutoRaise: %s\n",
XmToggleButtonGadgetGetState (dtwm.autoRaiseTG)
? "True" : "False");
changeFlag = 1;
}
state = !XmToggleButtonGadgetGetState (dtwm.secStackTG);
if ( state != dtwm.origSecStack)
{
sprintf(dtwmRes+strlen(dtwmRes), "Dtwm*secondariesOnTop: %s\n",
XmToggleButtonGadgetGetState (dtwm.secStackTG)
? "False" : "True");
changeFlag = 1;
}
state = XmToggleButtonGadgetGetState (dtwm.moveOpaqueTG);
if ( state != dtwm.origMoveOpaque)
{
sprintf(dtwmRes+strlen(dtwmRes), "Dtwm*moveOpaque: %s\n",
XmToggleButtonGadgetGetState (dtwm.moveOpaqueTG)
? "True" : "False");
changeFlag = 1;
}
state = XmToggleButtonGadgetGetState (dtwm.iconBoxTG);
if (state != dtwm.origUseIconBox)
{
sprintf(dtwmRes+strlen(dtwmRes), "Dtwm*useIconBox: %s\n",
XmToggleButtonGadgetGetState (dtwm.iconBoxTG)
? "True" : "False");
changeFlag = 1;
}
if (changeFlag)
{
if (dtwm.warnDialog == NULL)
{
n = 0;
XtSetArg(args[n], XmNokLabelString, CMPSTR((String) _DtOkString)); n++;
XtSetArg(args[n], XmNcancelLabelString, CMPSTR((String) _DtCancelString)); n++;
XtSetArg(args[n], XmNborderWidth, 3); n++;
XtSetArg(args[n], XmNmwmFunctions, DIALOG_MWM_FUNC ); n++;
XtSetArg(args[n], XmNdialogStyle, XmDIALOG_FULL_APPLICATION_MODAL); n++;
XtSetArg(args[n], XmNdialogTitle, CMPSTR((char *)GETMESSAGE(2,2, "Notice"))); n++;
XtSetArg(args[n], XmNmessageString, CMPSTR(WARN_MSG)); n++;
dtwm.warnDialog = XmCreateInformationDialog(style.shell, "warnDialog", args, n);
XtUnmanageChild (XmMessageBoxGetChild(dtwm.warnDialog, XmDIALOG_HELP_BUTTON));
XtAddCallback(dtwm.warnDialog, XmNokCallback, okWarnCB,
client_data);
XtAddCallback(dtwm.warnDialog, XmNcancelCallback, cancelWarnCB,
client_data);
}
XtManageChild(dtwm.warnDialog);
}
break;
case CANCEL_BUTTON:
/* reset to dtwm values from when dialog is mapped */
XtUnmanageChild(w);
XmToggleButtonGadgetSetState (dtwm.pointerTG,
dtwm.origKeyboardFocusPolicy ? POINTER : EXPLICIT , True);
XmToggleButtonGadgetSetState (dtwm.explicitTG,
dtwm.origKeyboardFocusPolicy ? EXPLICIT : POINTER , True);
XmToggleButtonGadgetSetState (dtwm.autoRaiseTG,
dtwm.origFocusAutoRaise ? True : False , True);
XmToggleButtonGadgetSetState (dtwm.secStackTG,
dtwm.origSecStack ? False : True , True);
XmToggleButtonGadgetSetState (dtwm.moveOpaqueTG,
dtwm.origMoveOpaque ? True : False , True);
XmToggleButtonGadgetSetState (dtwm.iconBoxTG,
dtwm.origUseIconBox ? True : False , True);
XmToggleButtonGadgetSetState (dtwm.desktopTG,
dtwm.origUseIconBox ? False : True , True);
break;
case HELP_BUTTON:
XtCallCallbacks(style.dtwmDialog, XmNhelpCallback, (XtPointer)NULL);
break;
default:
break;
}
}
void CChangeJavaFunctionPermissionsAction::OnPermissionChanged(Widget widget,XtPointer client_data,XtPointer call_data) {
CChangeJavaFunctionPermissionsAction* pThis = (CChangeJavaFunctionPermissionsAction*)client_data;
XmToggleButtonCallbackStruct* state = (XmToggleButtonCallbackStruct*) call_data;
if(!state->set) {
if (CChangeJavaFunctionPermissionsAction::isClassFinal && !XmToggleButtonGadgetGetState(pThis->m_finalInd)) {
pThis->PopupErrorDialog( "The class this function belongs to is final, you can not make this function non-final.");
XmToggleButtonGadgetSetState(pThis->m_finalInd, true, true);
}
}
if(state->set) {
if(widget == pThis->m_publicInd) pThis->setPermission(PUBLIC);
else if(widget == pThis->m_privateInd)
{
Boolean bAbstract = XmToggleButtonGadgetGetState(pThis->m_abstractInd);
if ( bAbstract )
{
pThis->PopupErrorDialog( "Function cannot be both Private and Abstract." );
if ( pThis->getPermission() == PACKAGE )
XmToggleButtonGadgetSetState(pThis->m_packageInd,true,true);
else if ( pThis->getPermission() == PROTECTED )
XmToggleButtonGadgetSetState(pThis->m_protectedInd,true,true);
else if ( pThis->getPermission() == PUBLIC )
XmToggleButtonGadgetSetState(pThis->m_publicInd,true,true);
//XmToggleButtonGadgetSetState(pThis->m_privateInd,false,true);
//XmToggleButtonGadgetSetState(pThis->m_packageInd,(pThis->getPermission()==PACKAGE),true);
//XmToggleButtonGadgetSetState(pThis->m_protectedInd,(pThis->getPermission()==PROTECTED),true);
//XmToggleButtonGadgetSetState(pThis->m_publicInd,(pThis->getPermission()==PUBLIC),true);
}
else
pThis->setPermission(PRIVATE);
}
else if(widget == pThis->m_protectedInd) pThis->setPermission(PROTECTED);
else if(widget == pThis->m_packageInd) pThis->setPermission(PACKAGE);
else if(widget == pThis->m_abstractInd)
{
Boolean bStatic = XmToggleButtonGadgetGetState(pThis->m_staticInd);
Boolean bFinal = XmToggleButtonGadgetGetState(pThis->m_finalInd);
Boolean bNative = XmToggleButtonGadgetGetState(pThis->m_nativeInd);
if ( pThis->getPermission() == PRIVATE )
{
pThis->PopupErrorDialog( "Function cannot be both Private and Abstract." );
XmToggleButtonGadgetSetState(pThis->m_abstractInd,false,true);
}
else if ( bStatic )
{
pThis->PopupErrorDialog( "Function cannot be both Static and Abstract." );
XmToggleButtonGadgetSetState(pThis->m_abstractInd,false,true);
}
else if ( bFinal )
{
pThis->PopupErrorDialog( "Function cannot be both Final and Abstract." );
XmToggleButtonGadgetSetState(pThis->m_abstractInd,false,true);
}
else if ( bNative )
{
pThis->PopupErrorDialog( "Function cannot be both Native and Abstract." );
XmToggleButtonGadgetSetState(pThis->m_abstractInd,false,true);
}
}
else if(widget == pThis->m_staticInd)
{
Boolean bAbstract = XmToggleButtonGadgetGetState(pThis->m_abstractInd);
if ( bAbstract )
{
pThis->PopupErrorDialog( "Function cannot be both Static and Abstract." );
XmToggleButtonGadgetSetState(pThis->m_staticInd,false,true);
}
}
else if(widget == pThis->m_finalInd)
{
Boolean bAbstract = XmToggleButtonGadgetGetState(pThis->m_abstractInd);
if ( bAbstract )
{
pThis->PopupErrorDialog( "Function cannot be both Final and Abstract." );
XmToggleButtonGadgetSetState(pThis->m_finalInd,false,true);
}
}
else if(widget == pThis->m_nativeInd)
{
Boolean bAbstract = XmToggleButtonGadgetGetState(pThis->m_abstractInd);
if ( bAbstract )
{
pThis->PopupErrorDialog( "Function cannot be both Native and Abstract." );
XmToggleButtonGadgetSetState(pThis->m_nativeInd,false,true);
}
}
}
}
void
ApptDragStart(
Widget widget,
XEvent *event,
Calendar *calendar,
EditorType editor_type)
{
static XtCallbackRec convertCBRec[] = { {ApptConvertCB, NULL},
{NULL, NULL} };
static XtCallbackRec dragFinishCBRec[] = { {DragFinishCB, NULL},
{NULL, NULL} };
Display *display = XtDisplay(widget);
DragContext *context = calloc(sizeof(DragContext), 1);
Editor *e = (Editor *) calendar->editor;
GEditor *ge = (GEditor *) calendar->geditor;
ToDo *t = (ToDo *) calendar->todo;
Dtcm_appointment *appt;
char *apptstr;
int preDsswFlags, preRfpFlags;
context->calendar = calendar;
context->editor_type = editor_type;
if (editor_type == SingleEditorIcon)
{
context->editor = (caddr_t) e;
appt = allocate_appt_struct(appt_write, DATAVER_ARCHIVE, NULL);
load_appt_defaults(appt, (Props *) calendar->properties);
preDsswFlags = e->dsswFlags;
preRfpFlags = e->rfpFlags;
if (!dssw_form_flags_to_appt(&e->dssw, appt,
calendar->calname,
now(), &e->dsswFlags) ||
!rfp_form_flags_to_appt(&e->rfp, appt,
calendar->calname,
&e->rfpFlags) ||
(preDsswFlags != e->dsswFlags) ||
(preRfpFlags != e->rfpFlags))
{
e->doing_drag = False;
free_appt_struct(&appt);
free(context);
return;
}
}
else if (editor_type == GroupEditorIcon)
{
context->editor = (caddr_t) ge;
appt = allocate_appt_struct(appt_write, DATAVER_ARCHIVE, NULL);
load_appt_defaults(appt, (Props *) calendar->properties);
preDsswFlags = ge->dsswFlags;
preRfpFlags = ge->rfpFlags;
if (!dssw_form_flags_to_appt(&ge->dssw, appt,
calendar->calname,
now(), &ge->dsswFlags) ||
!rfp_form_flags_to_appt(&ge->rfp, appt,
calendar->calname,
&ge->rfpFlags) ||
(preDsswFlags != ge->dsswFlags) ||
(preRfpFlags != ge->rfpFlags))
{
ge->doing_drag = False;
free_appt_struct(&appt);
free(context);
return;
}
}
else if (editor_type == TodoEditorIcon)
{
context->editor = (caddr_t) t;
if (t->cal->general->version < DATAVER4)
appt = allocate_appt_struct(appt_write, DATAVER_ARCHIVE,
CSA_ENTRY_ATTR_REFERENCE_IDENTIFIER_I,
CSA_ENTRY_ATTR_LAST_UPDATE_I,
CSA_ENTRY_ATTR_ORGANIZER_I,
CSA_ENTRY_ATTR_START_DATE_I,
CSA_ENTRY_ATTR_TYPE_I,
CSA_ENTRY_ATTR_CLASSIFICATION_I,
CSA_ENTRY_ATTR_END_DATE_I,
CSA_X_DT_ENTRY_ATTR_SHOWTIME_I,
CSA_ENTRY_ATTR_SUMMARY_I,
CSA_ENTRY_ATTR_STATUS_I,
CSA_X_DT_ENTRY_ATTR_REPEAT_TYPE_I,
CSA_X_DT_ENTRY_ATTR_REPEAT_TIMES_I,
CSA_X_DT_ENTRY_ATTR_REPEAT_INTERVAL_I,
CSA_X_DT_ENTRY_ATTR_REPEAT_OCCURRENCE_NUM_I,
CSA_ENTRY_ATTR_AUDIO_REMINDER_I,
CSA_ENTRY_ATTR_FLASHING_REMINDER_I,
CSA_ENTRY_ATTR_MAIL_REMINDER_I,
CSA_ENTRY_ATTR_POPUP_REMINDER_I,
NULL);
else
appt = allocate_appt_struct(appt_write,
DATAVER_ARCHIVE, NULL);
dssw_form_to_todo(&t->dssw, appt, calendar->calname, now());
preRfpFlags = t->rfpFlags;
if (!rfp_form_flags_to_appt(&t->rfp, appt,
calendar->calname,
&t->rfpFlags) ||
(preRfpFlags != t->rfpFlags))
{
t->doing_drag = False;
free_appt_struct(&appt);
free(context);
return;
}
appt->type->value->item.sint32_value = CSA_TYPE_TODO;
appt->show_time->value->item.sint32_value = True;
t->completed_val =
XmToggleButtonGadgetGetState(t->completed_toggle);
appt->state->value->item.sint32_value =
(t->completed_val) ?
CSA_STATUS_COMPLETED : CSA_X_DT_STATUS_ACTIVE;
}
else
{
free(context);
return;
}
apptstr = parse_attrs_to_string(appt, (Props *)calendar->properties,
attrs_to_string(appt->attrs,
appt->count));
free_appt_struct(&appt);
context->data = apptstr;
GetIcon(calendar);
convertCBRec[0].closure = (XtPointer)context;
dragFinishCBRec[0].closure = (XtPointer)context;
if (e->drag_icon == NULL) {
e->drag_icon = CreateDragSourceIcon(widget, e->drag_bitmap,
e->drag_mask);
}
if (DtDndVaDragStart(widget, event, DtDND_BUFFER_TRANSFER, 1,
XmDROP_COPY,
convertCBRec, dragFinishCBRec,
DtNsourceIcon, e->drag_icon,
NULL)
== NULL) {
printf(catgets(calendar->DT_catd, 1, 239,
"DragStart returned NULL.\n"));
}
}
