external/cde
1
0
Fork 0
mirror of git://git.code.sf.net/p/cdesktopenv/code synced 2025-03-09 15:50:02 +00:00
Code Issues Releases Wiki Activity
cde/cde/programs/dtlogin/vgmain.c
wmoxam e1e2004696 Remove unused HP_EXTENSIONS code blocks
2019-10-14 15:54:25 -06:00

2276 lines
64 KiB
C
Raw Blame History

/*
* CDE - Common Desktop Environment
*
* Copyright (c) 1993-2012, The Open Group. All rights reserved.
*
* These libraries and programs are free software; you can
* redistribute them and/or modify them under the terms of the GNU
* Lesser General Public License as published by the Free Software
* Foundation; either version 2 of the License, or (at your option)
* any later version.
*
* These libraries and programs are distributed in the hope that
* they will be useful, but WITHOUT ANY WARRANTY; without even the
* implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE. See the GNU Lesser General Public License for more
* details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with these libraries and programs; if not, write
* to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
* Floor, Boston, MA 02110-1301 USA
*/
/* $TOG: vgmain.c /main/19 1998/09/14 18:31:11 mgreess $ */
/* *
* (c) Copyright 1993, 1994 Hewlett-Packard Company *
* (c) Copyright 1993, 1994 International Business Machines Corp. *
* (c) Copyright 1993, 1994 Sun Microsystems, Inc. *
* (c) Copyright 1993, 1994 Novell, Inc. *
*/
/****************************************************************************
**
** File: vgmain.c
**
** Project: HP Visual User Environment (DT)
**
** Description: Main line code for Dtgreet application
**
** These routines initialize the toolkit, create the widgets,
** set up callbacks, and wait for events.
**
**
** (c) Copyright 1987, 1988, 1989 by Hewlett-Packard Company
**
**
**
****************************************************************************
************************************<+>*************************************/
/***************************************************************************
*
* Includes
*
***************************************************************************/
#include <stdio.h>
#include <setjmp.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/signal.h>
#include <sys/stat.h>
#include <sys/param.h>
#include <locale.h>
#include <netdb.h>
#include <Xm/Xm.h>
#include <X11/Xfuncs.h>
#include <X11/Shell.h>
#include <X11/cursorfont.h>
#include <Xm/DragC.h>
#include <Xm/DrawingA.h>
#include <Xm/Frame.h>
#include <Xm/Form.h>
#include <Xm/Label.h>
#include <Xm/LabelG.h>
#include <Xm/Text.h>
#include <Xm/TextF.h>
#include <Xm/PushB.h>
#include <Xm/PushBG.h>
#include <Xm/MessageB.h>
#include <Xm/RowColumn.h>
#include <Xm/SeparatoG.h>
#include <Xm/ToggleBG.h>
#include <Xm/CascadeBG.h>
#include <Dt/EnvControlP.h>
#include "vg.h"
#include "vgmsg.h"
#include <Dt/MenuButton.h>
#ifdef USE_XINERAMA
#include <DtXinerama.h>
#endif
#if !defined(NL_CAT_LOCALE)
#define NL_CAT_LOCALE 0
#endif
#define LOCALHOST "%LocalHost%"
#define DISPLAYNAME "%DisplayName%"
/***************************************************************************
*
* External declarations
*
***************************************************************************/
extern char password[]; /* pswd string value */
extern int password_length; /* pswd string length */
/***************************************************************************
*
* Procedure declarations
*
***************************************************************************/
static SIGVAL syncTimeout( int arg ) ;
static Widget InitToolKit( int argc, char **argv) ;
static void MakeRootCursor( void ) ;
static void MakeBackground( void ) ;
static void MakeButtons( void ) ;
static void MakeDtlabel( void );
static void MakeGreeting( void ) ;
static void MakeLogin( void ) ;
static void MyInsert( Widget w, XEvent *event, char **params,
Cardinal *num_params) ;
static void MyBackspace( Widget w, XEvent *event, char **params,
Cardinal *num_params) ;
static int ErrorHandler( Display *dpy, XErrorEvent *event) ;
static void xtErrorHandler( String msg ) ;
static void xtWarningHandler( String msg ) ;
static void MakeOptionsProc( XtPointer data, XtIntervalId *id) ;
static SIGVAL Terminate( int arg ) ;
static char * GetLangName( char * label );
static void MakeAltDtButtons( void );
static void DebugWidgetResources(Widget w);
static char * GetDisplayName();
/***************************************************************************
*
* Global variables
*
***************************************************************************/
AppInfo appInfo; /* application resources */
Arg argt[100]; /* used for resources */
DisplayInfo dpyinfo; /* information about the display */
XmString xmstr; /* used for compound strings */
char *errorLogFile; /* current value of environment var. */
int showVerifyError;/* display a Verify() error dialog */
char altdtname[MAXPATHLEN];
char altdtclass[MAXPATHLEN];
char altdtkey[MAXPATHLEN];
char altdtkeyclass[MAXPATHLEN];
char altdtstart[MAXPATHLEN];
char altdtstartclass[MAXPATHLEN];
char altdtlogo[MAXPATHLEN];
char altlogoclass[MAXPATHLEN];
char *langenv;
char *logotype; /* for XrmGetResource() */
XrmValue logovalue; /* for XrmGetResource() */
char *rmtype;
XrmValue rmvalue;
char *keyrmtype;
XrmValue keyrmvalue;
/******************************************************************************
**
** WIDGET LAYOUT
**
** toplevel "main" (toplevel)
** login_shell "login_shell" (overrideShell)
** table "table" (DrawingAreaWidget)
** copyright_msg "copyright_msg" (MessageBox)
** error_message "error_message" (MessageBox)
** help_message "help_message" (MessageBox)
** passwd_message "passwd_message" (MessageBox)
** hostname_message "hostname_msg" (MessageBox)
** matte "matte" (FormWidget)
** logo "logo" (FrameWidget)
** logo_pixmap "logo_pixmap" (LabelGadget)
** matteFrame "matteFrame" (FrameWidget)
** matte1 "matte1" (FormWidget)
** help_button "help_button" (PushButtonGadget)
** greeting "greeting" (LabelGadget)
** dt_label "dt_label" (LabelGadget)
** login_form "login_form" (FormWidget)
** login_label "login_label" (LabelGadget)
** login_text "login_text" (TextField)
** passwd_text "passwd_text" (TextField)
** ok_button "ok_button" (PushButtonGadget)
** clear_button "clear_button" (PushButtonGadget)
** options_button "options_button" (DtMenuButtonWidget)
** options_menu "options_menu" (PopupMenu)
** options_item[0] "options_languages" (CascadeButtonGadget)
** options_item[1] "options_sep2" (SeparatorGadget)
** options_item[2] "session_menus" (CascadeButtonGadget)
** options_item[3] "options_sep1" (SeparatorGadget)
** options_item[4] "options_noWindows" (PushButtonGadget)
** options_item[5] "options_restartServer"(PushButtonGadget)
** options_item[6] "options_sep1" (SeparatorGadget)
** options_item[7] "options_Copyright" (PushButtonGadget)
** session_menu "session_menu" (PulldownMenu)
** options_dt "options_dt" (ToggleButtonGadget)
** options_failsafe "options_failsafe" (ToggleButtonGadget)
** lang_menu "lang_menu" (PulldownMenu)
** (lang items) (lang items) (ToggleButtonGadget)
** ...
**
*/
Widget toplevel; /* top level shell widget */
Widget login_shell; /* shell for the main login widgets. */
Widget table; /* black background for everything */
Widget matte; /* main level form widget */
Widget matteFrame; /* main level form widget */
Widget matte1; /* second level form widget */
Widget greeting; /* Welcome message */
Widget dt_label; /* Desktop i.e. set in options menu */
Widget logo1; /* frame around the Corporate logo */
Widget logo_pixmap; /* Corporate logo */
Widget logo_shadow; /* drop shadow under the Corporate logo */
Widget login_matte; /* bulletin board for login/password */
Widget login_form; /* form containing the login widgets */
Widget login_label; /* label to left of login text widget */
Widget login_text; /* login text widget */
Widget ok_button; /* accept name/password text button */
Widget clear_button; /* clear name/password text button */
Widget options_button; /* login options button */
Widget help_button; /* help button */
Widget copyright_msg = NULL; /* copyright notice widget */
Widget help_message = NULL; /* the help message box */
Widget error_message = NULL; /* the error message box */
Widget hostname_message = NULL; /* the invalid hostname message box */
Widget passwd_message = NULL; /* the expired password message box */
Widget options_menu = NULL; /* pop-up menu on options button */
Widget options_item[10]; /* items on options pop_up menu */
Widget options_nowindows; /* nowindows pane on options pop_up menu */
Widget options_failsafe; /* failsafe pane on options pop_up menu */
Widget options_dtlite; /* dtlite pane on options pop_up menu */
Widget *alt_dts; /* alt_dts widgets on options pop_up menu */
Widget options_dt; /* dt regular pane on options pop_up menu */
Widget options_last_dt; /* user's last dt */
Widget lang_menu = NULL; /* cascading menu on "Language" option */
Widget session_menu = NULL; /* cascading menu on "Session" option */
/***************************************************************************
*
* Text widget actions and translations
*
***************************************************************************/
static XtActionsRec textActions[] = {
{"my-insert", (XtActionProc)MyInsert},
{"my-bksp", (XtActionProc)MyBackspace},
};
static char textEventBindings[] = {
"Shift <Key>Tab: prev-tab-group() \n\
Ctrl <Key>Tab: next-tab-group() \n\
<Key>osfEndLine: end-of-line() \n\
<Key>osfBeginLine: beginning-of-line() \n\
~Shift <Key>osfRight: forward-character()\n\
~Shift <Key>osfLeft: backward-character()\n\
Ctrl <Key>osfDelete: delete-to-end-of-line()\n\
<Key>osfDelete: delete-next-character()\n\
<Key>osfBackSpace: my-bksp()\n\
<Key>osfActivate: activate()\n\
Ctrl <Key>Return: activate()\n\
<Key>Return: activate()\n\
<Key>: my-insert()\n\
~Ctrl ~Shift ~Meta ~Alt<Btn1Down>: grab-focus() \n\
<EnterWindow>: enter()\n\
<LeaveWindow>: leave()\n\
<FocusIn>: focusIn()\n\
<FocusOut>: focusOut()\n\
<Unmap>: unmap()"
};
static
XtResource AppResources[] = {
{ "workspaceCursor", "WorkspaceCursor",
XtRBoolean, sizeof(Boolean), XtOffset(AppInfoPtr, workspaceCursor),
XtRImmediate, (caddr_t)False },
{ "labelFont", "LabelFont",
XmRFontList, sizeof(XmFontList), XtOffset(AppInfoPtr, labelFont),
XmRString, "Fixed" },
{ "textFont", "TextFont",
XmRFontList, sizeof(XmFontList), XtOffset(AppInfoPtr, textFont),
XmRString, "Fixed" },
{ "optionsDelay", "OptionsDelay",
XtRInt, sizeof(int), XtOffset(AppInfoPtr, optionsDelay),
XtRImmediate, (XtPointer) 0 },
{ "altDts", "AltDts",
XtRInt, sizeof(int), XtOffset(AppInfoPtr, altDts),
XtRImmediate, (XtPointer) 0
},
{"languageList", "LanguageList",
XtRString, sizeof(char *), XtOffset(AppInfoPtr, languageList),
XtRString, NULL },
#if defined(USE_XINERAMA)
{ "xineramaPreferredScreen", "XineramaPreferredScreen",
XtRInt, sizeof(int), XtOffset(AppInfoPtr, xineramaPreferredScreen),
XtRImmediate, (XtPointer) 0
},
#endif
#if defined (ENABLE_DYNAMIC_LANGLIST)
{"languageListCmd", "LanguageListCmd",
XtRString, sizeof(char *), XtOffset(AppInfoPtr, languageListCmd),
XtRString, NULL },
#endif /* ENABLE_DYNAMIC_LANGLIST */
};
/***************************************************************************
*
* Main
*
***************************************************************************/
int
main( int argc, char **argv )
{
char *session;
int i; /* index for argt */
char **p; /* temp pointer to traverse argv */
Boolean nograb=FALSE; /* debugging option to not grab server/key */
int debug=0; /* print debugging output */
#ifdef VG_TRACE
vg_TRACE_EXECUTION("--------------------- main ------------------------");
#endif /* VG_TRACE */
setlocale(LC_ALL, "");
XtSetLanguageProc( NULL, NULL, NULL );
langenv = getenv("LANG");
/*
* set TERM signal handler...
*/
(void) signal(SIGTERM, Terminate);
#ifdef BLS
# ifndef NDEBUG
{
extern SIGVAL BLS_ToggleDebug( int arg );
/*
* Allow debug output to be turned on for dtgreet.
*/
(void) signal(SIGHUP, BLS_ToggleDebug);
}
# endif /* NDEBUG */
/*
* set up authorization parameters, see the identity(3) man page...
*/
if (ISSECURE) {
set_auth_parameters(1, argv);
init_security();
}
#endif /* BLS */
/*
* check some environment variables...
*/
errorLogFile = getenv(ERRORLOG);
#ifdef sun
if (getenv("OPENWINHOME") == NULL) putenv(OWPATH_ENV);
#endif
_DtEnvControl( DT_ENV_SET );
/*
* set custom error handler for X protocol errors...
*/
XSetErrorHandler(ErrorHandler);
/*
* scan argv looking for display name...
*/
showVerifyError = 0;
for ( i = argc, p = argv; i > 0; i--, p++ ) {
if ( strcmp(*p, "-display") == 0) {
p++;
i--;
dpyinfo.name = malloc(strlen(*p) + 1);
strcpy(dpyinfo.name, *p);
continue;
}
if ( strcmp(*p, "-debug") == 0) {
p++;
i--;
debug = atoi(*p);
continue;
}
if ( strcmp(*p, "-nograb") == 0) {
nograb = TRUE;
continue;
}
if ( strcmp(*p, "-showerror") == 0) {
p++;
i--;
showVerifyError = atoi(*p);
continue;
}
}
#ifdef VG_TRACE
vg_TRACE_EXECUTION("main: after options.");
#endif /* VG_TRACE */
#ifdef VG_DEBUG
#ifdef __hpux
while (1) {}
#else
LogError((unsigned char *) "main: sleeping %d seconds.\n", debug);
if (debug) {
sleep(debug);
}
#endif /* __hpux */
#endif /* VG_DEBUG */
/*
* initialize the Intrinsics...
*/
toplevel = InitToolKit(argc, argv);
#ifdef VG_TRACE
vg_TRACE_EXECUTION("main: exited InitToolKit ...");
#endif /* VG_TRACE */
if (debug) {
XtSetErrorHandler(xtErrorHandler);
XtSetWarningHandler(xtWarningHandler);
}
#ifdef __hpux
/*
* prevent the toolkit from starting the NLIO server...
*/
#ifdef VG_TRACE
vg_TRACE_EXECUTION("main: exited _XHPNlioctl ...");
#endif /* VG_TRACE */
#endif
/*
* get information about the display...
*/
dpyinfo.dpy = XtDisplay(toplevel);
/* dpyinfo.name = "";*/
dpyinfo.screen = DefaultScreen(dpyinfo.dpy);
dpyinfo.root = RootWindow (dpyinfo.dpy, dpyinfo.screen);
dpyinfo.depth = DefaultDepth (dpyinfo.dpy, dpyinfo.screen);
dpyinfo.width = DisplayWidth (dpyinfo.dpy, dpyinfo.screen);
dpyinfo.height = DisplayHeight(dpyinfo.dpy, dpyinfo.screen);
dpyinfo.black_pixel = BlackPixel (dpyinfo.dpy, dpyinfo.screen);
dpyinfo.visual = DefaultVisual(dpyinfo.dpy, dpyinfo.screen);
/* JET - for Xinerama, see if the extension */
/* is available and init accordingly. */
#ifdef USE_XINERAMA
dpyinfo.DtXineramaInfo = _DtXineramaInit(dpyinfo.dpy);
# ifdef DEBUG
if (dpyinfo.DtXineramaInfo == NULL)
{ /* No xinerama, no joy. */
fprintf(stderr, "### JET VGMAIN: Xinerama NOT available.\n");
}
else
{
fprintf(stderr, "### JET VGMAIN: Xinerama available, scrns = %d\n",
dpyinfo.DtXineramaInfo->numscreens);
}
# endif
#endif
/*
* check if any overrides were passed in the argv string...
*/
for ( i = 1; i < argc; i++) {
switch(i) {
default:
break;
}
}
/*
* add the unit convertor for resources...
*/
XtAddConverter(XmRString, XmRUnitType, XmCvtStringToUnitType, NULL, 0);
/*
* get user-specified resources...
*/
SetResourceDatabase();
XtGetApplicationResources(toplevel, &appInfo, AppResources,
XtNumber(AppResources), NULL, 0);
#ifdef VG_TRACE
vg_TRACE_EXECUTION("main: got application resources ...");
#endif /* VG_TRACE */
/*
* build widgets...
*/
#ifdef VG_TRACE
vg_TRACE_EXECUTION("main: making UI ...");
#endif /* VG_TRACE */
MakeBackground(); /* login_shell, table, matte */
MakeLogo(); /* logo, logo_pixmap, logo_shadow */
MakeGreeting(); /* greeting */
MakeLogin(); /* login_matte ... */
MakeDtlabel(); /* Show Desktop selection in options menu*/
/*
* grab the display and keyboard...
* moved it from before to after creating text widgets in MakeLogin
* RK 01.11.94
*/
if ( ! nograb )
SecureDisplay();
MakeButtons(); /* ok, clear, options, help buttons */
MakeDialog(copyright); /* copyright dialog */
if (appInfo.optionsDelay == 0 )
MakeOptionsMenu(); /* make option_button pop-up menu */
else
XtAddTimeOut((unsigned long) appInfo.optionsDelay * 1000,
MakeOptionsProc, NULL);
MakeAltDtButtons(); /* make alt desktop buttons, if any */
#ifdef VG_TRACE
vg_TRACE_EXECUTION("main: made UI ...");
#endif /* VG_TRACE */
/*
* Add request callback.
XtAddInput(0, (XtPointer)XtInputReadMask, RequestCB, NULL);
*/
/*
* force the focus to the login_text widget...
*/
/*
XtAddEventHandler(login_text, ExposureMask, False,
FakeFocusIn, NULL);
*/
/*
* create windows for the widgets...
*/
#ifdef VG_TRACE
vg_TRACE_EXECUTION("main: going to realize login_shell ...");
#endif /* VG_TRACE */
XtRealizeWidget(login_shell);
#ifdef VG_TRACE
vg_TRACE_EXECUTION("main: realized login_shell ...");
#endif /* VG_TRACE */
/*
* miscellaneous stuff...
*
* - turn off keyboard bell
* - return root cursor to normal from hourglass
* - start pinging the server
*/
ChangeBell("off");
if (appInfo.workspaceCursor)
{
MakeRootCursor();
}
else
{
XUndefineCursor(dpyinfo.dpy, dpyinfo.root);
}
PingServerCB(NULL, NULL);
/*
* bring up the windows and enter event loop...
*/
XRaiseWindow(XtDisplay(greeting), XtWindow(greeting));
/*
XRaiseWindow(XtDisplay(logo_shadow), XtWindow(logo_shadow));
XRaiseWindow(XtDisplay(logo), XtWindow(logo));
*/
/* XtPopup(login_shell, XtGrabNone); */
_DtEnvControl( DT_ENV_RESTORE_PRE_DT );
/*
* Add request callback.
*/
sleep(5);
XtAddInput(0, (XtPointer)XtInputReadMask, RequestCB, NULL);
#ifdef VG_TRACE
vg_TRACE_EXECUTION("main: entering XtMainLoop ...");
#endif /* VG_TRACE */
XtMainLoop();
exit (0);
}
/***************************************************************************
*
* InitToolKit
*
* initialize the toolkit
***************************************************************************/
#define MINTIMEOUT 20
static jmp_buf syncJump;
static SIGVAL
syncTimeout( int arg )
{
longjmp (syncJump, 1);
}
static Widget
InitToolKit( int argc, char **argv )
{
int timeout; /* timeout to initialize toolkit */
char *t;
Widget root;
#ifdef VG_TRACE
vg_TRACE_EXECUTION("InitToolKit: enter ...");
#endif /* VG_TRACE */
/*
* use server grabTimeout as initial value for timeout...
*/
timeout = ((t = (char *)getenv(GRABTIMEOUT)) == NULL ? 0 : atoi(t));
timeout += MINTIMEOUT; /* minimum MINTIMEOUT seconds */
/*
* initialize the toolkit. Wrap a timer around it in case the server
* is grabbed.
*/
signal (SIGALRM, syncTimeout);
if (setjmp (syncJump)) {
LogError(
ReadCatalog(MC_LOG_SET,MC_LOG_NO_DPYINIT,MC_DEF_LOG_NO_DPYINIT),
dpyinfo.name);
exit(NOTIFY_RESTART);
}
alarm ((unsigned) timeout);
root = XtInitialize("dtlogin", "Dtlogin", NULL, 0,
&argc, argv);
/* Disable Drag and Drop RK 11.02.93 */
XtVaSetValues(XmGetXmDisplay(XtDisplay(root)),
XmNdragInitiatorProtocolStyle, XmDRAG_NONE,
NULL);
alarm (0);
signal (SIGALRM, SIG_DFL);
return(root);
}
/***************************************************************************
*
* MakeRootCursor
*
* Widgets: none
***************************************************************************/
static void
MakeRootCursor( void )
{
Cursor vg_cursor;
vg_cursor = XCreateFontCursor (dpyinfo.dpy, XC_left_ptr);
XDefineCursor (dpyinfo.dpy, dpyinfo.root, vg_cursor);
return;
}
/***************************************************************************
*
* MakeBackground
*
* Widgets: login_shell, table, matte
***************************************************************************/
static void
MakeBackground( void )
{
int i;
#ifdef VG_TRACE
vg_TRACE_EXECUTION("MakeBackground: entered ...");
#endif /* VG_TRACE */
/*
* create the login shell widget...
*/
i = 0;
/* CORE resource set */
XtSetArg(argt[i], XmNancestorSensitive, True ); i++;
XtSetArg(argt[i], XmNbackgroundPixmap, XmUNSPECIFIED_PIXMAP ); i++;
XtSetArg(argt[i], XmNborderWidth, 0 ); i++;
XtSetArg(argt[i], XmNmappedWhenManaged, False ); i++;
XtSetArg(argt[i], XmNsensitive, True ); i++;
XtSetArg(argt[i], XmNtranslations, NULL ); i++;
/* COMPOSITE resource set */
XtSetArg(argt[i], XmNinsertPosition, NULL ); i++;
/* SHELL resource set (set to avoid interference by user) */
XtSetArg(argt[i], XmNallowShellResize, False ); i++;
XtSetArg(argt[i], XmNcreatePopupChildProc, NULL ); i++;
XtSetArg(argt[i], XmNgeometry, NULL ); i++;
XtSetArg(argt[i], XmNpopupCallback, NULL ); i++;
XtSetArg(argt[i], XmNpopdownCallback, NULL ); i++;
XtSetArg(argt[i], XmNoverrideRedirect, False ); i++;
XtSetArg(argt[i], XmNsaveUnder, False ); i++;
login_shell = XtCreatePopupShell("login_shell", transientShellWidgetClass,
toplevel, argt, i);
XtAddCallback(login_shell, XmNpopupCallback, LayoutCB, NULL);
/* Fix to display Input Method's status area. */
XtSetArg(argt[0], XmNheight, dpyinfo.height);
XtSetValues(login_shell, argt, 1);
/*
* create the full-screen drawing area...
*/
i = InitArg(DrawingA);
XtSetArg(argt[i], XmNwidth, dpyinfo.width ); i++;
XtSetArg(argt[i], XmNheight, dpyinfo.height ); i++;
XtSetArg(argt[i], XmNunitType, XmPIXELS ); i++;
table = XtCreateManagedWidget("table", xmDrawingAreaWidgetClass,
login_shell, argt, i);
XtAddEventHandler(table, ButtonPressMask, False, RefreshEH, NULL);
XtAddCallback(table, XmNhelpCallback, ShowDialogCB, (XtPointer) help);
/*
* create the main matte...
*/
i = InitArg(Form);
/* XmNwidth, (set by user) */
/* XmNheight, (set by user) */
XtSetArg(argt[i], XmNshadowThickness, SHADOW_THICKNESS ); i++;
/*
XtSetArg(argt[i], XmNshadowType, XmSHADOW_OUT ); i++;
XtSetArg(argt[i], XmNshadowThickness, 5 ); i++;
*/
matte = XmCreateForm(table, "matte", argt, i);
XtManageChild(matte);
i = 0;
XtSetArg(argt[i], XmNshadowType, XmSHADOW_OUT); i++;
XtSetArg(argt[i], XmNshadowThickness, 2); i++;
XtSetArg(argt[i], XmNtopAttachment, XmATTACH_FORM); i++;
XtSetArg(argt[i], XmNbottomAttachment, XmATTACH_FORM); i++;
XtSetArg(argt[i], XmNleftAttachment, XmATTACH_FORM); i++;
/*
XtSetArg(argt[i], XmNrightAttachment, XmATTACH_FORM); i++;
*/
XtSetArg(argt[i], XmNtopOffset, 15); i++;
XtSetArg(argt[i], XmNbottomOffset, 15); i++;
XtSetArg(argt[i], XmNleftOffset, 15); i++;
/*
XtSetArg(argt[i], XmNrightOffset, 15); i++;
*/
matteFrame = XmCreateFrame(matte, "matteFrame", argt, i);
XtManageChild(matteFrame);
i = 0;
matte1 = XmCreateForm(matteFrame, "matte1", argt, i);
XtManageChild(matte1);
}
static void
MakeAltDtButtons( void )
{
int i,j;
struct stat statb;
char *startup_name;
XrmValue startup_value;
char temp[MAXPATHLEN] = "\0";
char *session;
FILE *ls;
char lastsess[MAXPATHLEN];
Widget default_dt = NULL;
int default_is_custom_dt = True;
int found_alt_dt = False;
char *temp_p;
#ifdef VG_TRACE
vg_TRACE_EXECUTION("MakeAltDtButtons: entered ...");
#endif /* VG_TRACE */
if (getenv("SESSION_SET") == NULL) {
default_is_custom_dt = False;
}
if ((session = getenv ("SESSION")) == NULL) {
session = " ";
}
if(appInfo.altDts > 0) {
if ((alt_dts =
(Widget *) calloc(appInfo.altDts, sizeof (Widget))) == NULL)
LogError(
ReadCatalog(MC_ERROR_SET,MC_NO_MEMORY, MC_DEF_NO_MEMORY),
dpyinfo.name);
for(i = 0; i < appInfo.altDts; ++i) {
int is_default;
is_default = FALSE;
/* alt desktops begin numbering with 1 */
sprintf(altdtname,"%s%d", "Dtlogin*altDtName",i+1);
sprintf(altdtclass,"%s%d", "Dtlogin*AltDtName",i+1);
sprintf(altdtkey,"%s%d","Dtlogin*altDtKey",i+1);
sprintf(altdtkeyclass,"%s%d","Dtlogin*AltDtKey",i+1);
sprintf(altdtstart,"%s%d","Dtlogin*altDtStart",i+1);
sprintf(altdtstartclass,"%s%d","Dtlogin*AltDtStart",i+1);
if (XrmGetResource(
XtDatabase(dpyinfo.dpy),
altdtkey, altdtkeyclass,
&keyrmtype, &keyrmvalue) == True) {
/*
* remove trailing spaces
*/
if(strchr(keyrmvalue.addr,' '))
temp_p = strtok(keyrmvalue.addr," ");
else
temp_p = keyrmvalue.addr;
/*
* Make sure the key file exists.
*/
if (stat( temp_p, &statb) == 0) {
j = InitArg(ToggleBG);
if (XrmGetResource(
XtDatabase(dpyinfo.dpy),
altdtstart, altdtstartclass,
&startup_name, &startup_value) == True) {
/*
* remove trailing spaces
*/
if (strchr(startup_value.addr, ' '))
snprintf(temp, sizeof(temp), "%s", strtok(startup_value.addr, " "));
else
snprintf(temp, sizeof(temp), "%s", startup_value.addr);
if (default_is_custom_dt)
if (strcmp(session, temp) == 0) {
is_default = TRUE;
}
}
else
LogError((unsigned char *)"No startup script for altdt %d \n", i);
if (XrmGetResource(
XtDatabase(dpyinfo.dpy),
altdtname, altdtclass,
&rmtype, &rmvalue) == True) {
if (! strncmp(rmvalue.addr, DISPLAYNAME, strlen(DISPLAYNAME))) {
char *host;
host = GetDisplayName();
snprintf(temp, sizeof(temp), "%s - %s", host, rmvalue.addr + strlen(DISPLAYNAME));
xmstr = XmStringCreateLocalized(temp);
}
else {
xmstr = XmStringCreateLocalized(rmvalue.addr);
}
}
else {
LogError((unsigned char *)
"Couldn't find the altdtname resource in the db\n");
sprintf(altdtname,"%s%d", "Alternate Desktop-",i+1);
xmstr = XmStringCreateLocalized(altdtname);
}
sprintf(altdtlogo,"%s%d","Dtlogin*altDtLogo",i+1);
sprintf(altlogoclass,"%s%d","Dtlogin*AltDtLogo",i+1);
if (XrmGetResource(
XtDatabase(dpyinfo.dpy),
altdtlogo, altlogoclass,
&logotype, &logovalue) == True) {
XtSetArg(argt[j], XmNuserData, logovalue.addr); j++;
}
else{
XtSetArg(argt[j], XmNuserData, logoInfo.bitmapFile); j++;
}
XtSetArg(argt[j], XmNlabelString, xmstr); j++;
XtSetArg(argt[j], XmNrecomputeSize, True); j++;
alt_dts[i] = XmCreateToggleButtonGadget(
session_menu,
rmvalue.addr, argt, j);
XmStringFree(xmstr);
XtAddCallback(
alt_dts[i],
XmNvalueChangedCallback, MenuItemCB,
(XtPointer) OB_ALT_DTS);
XtManageChild(alt_dts[i]);
found_alt_dt = True;
if (is_default)
default_dt = alt_dts[i];
}
else
LogError((unsigned char *) "Couldn't find the keyfile \n");
}
else
LogError((unsigned char *)
"Couldn't find the altkeyfile resource in the database\n");
}
}
if ((appInfo.altDts == 0) || !found_alt_dt)
XtManageChild(options_dt);
/*
* Use the regular desktop if none of the known sessions matched the
* specified custom session.
*/
if (default_is_custom_dt && NULL == default_dt) {
default_dt = options_dt;
if (found_alt_dt)
XtManageChild(options_dt);
}
/*
* [ Failsafe Session ] menu pane...
*/
i = InitArg(ToggleBG);
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_FS_LABEL, MC_DEF_FS_LABEL);
XtSetArg(argt[i], XmNuserData, logoInfo.bitmapFile ); i++;
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
XtSetArg(argt[i], XmNrecomputeSize, True ); i++;
options_failsafe = XmCreateToggleButtonGadget(session_menu,
"options_failsafe", argt, i);
XmStringFree(xmstr);
XtAddCallback(options_failsafe, XmNvalueChangedCallback,
MenuItemCB, (XtPointer) OB_FAILSAFE);
XtManageChild(options_failsafe);
/*
* which option to set..
*/
SetDefaultDt(default_dt);
SetDtLabelAndIcon();
}
/***************************************************************************
*
* MakeButtons
*
* Widgets: ok_button, clear_button, options_button, help_button
***************************************************************************/
static void
MakeButtons( void )
{
int i;
Dimension max_width; /* maximum width of a set of widgets */
Dimension max_height; /* maximum height of a set of widgets */
Dimension thick1; /* defaultButtonShadowThickness */
Dimension thick2; /* shadowThickness */
int origin; /* horizontal origin for button placement */
int spacing; /* spacing between buttons (width/32) */
#ifdef VG_TRACE
vg_TRACE_EXECUTION("MakeButtons: entered ...");
#endif /* VG_TRACE */
/*
* create the buttons...
*/
/* ok button */
i = InitArg(PushBG);
XtSetArg(argt[i], XmNbottomAttachment, XmATTACH_POSITION); i++;
XtSetArg(argt[i], XmNbottomPosition, 95); i++;
XtSetArg(argt[i], XmNtraversalOn, True); i++;
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_OK_LABEL, MC_DEF_OK_LABEL );
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
ok_button = XmCreatePushButtonGadget(matte1, "ok_button", argt, i);
XmStringFree(xmstr);
XtManageChild(ok_button);
XtAddCallback(ok_button, XmNactivateCallback, RespondChallengeCB, NULL);
/* clear button */
i -= 1;
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_CLEAR_LABEL, MC_DEF_CLEAR_LABEL);
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
clear_button = XmCreatePushButtonGadget(matte1, "clear_button", argt, i);
XmStringFree(xmstr);
XtManageChild(clear_button);
XtAddCallback(clear_button, XmNactivateCallback, RespondClearCB,
(XtPointer) 0);
/* help button */
i -= 1;
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_HELP_LABEL, MC_DEF_HELP_LABEL);
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
help_button = XmCreatePushButtonGadget(matte1, "help_button", argt, i);
XtAddCallback(help_button, XmNactivateCallback, ShowDialogCB,
(XtPointer) help);
XmStringFree(xmstr);
XtManageChild(help_button);
/* options button */
i = InitArg(Label);
XtSetArg(argt[i], XmNbottomAttachment, XmATTACH_POSITION); i++;
XtSetArg(argt[i], XmNbottomPosition, 95); i++;
xmstr = ReadCatalogXms(
MC_LABEL_SET,
MC_OPTIONS_LABEL,
MC_DEF_OPTIONS_LABEL );
XtSetArg(argt[i], XmNlabelString, xmstr); i++;
XtSetArg(argt[i], XmNtraversalOn, True); i++;
options_button = DtCreateMenuButton(matte1, "options_button", argt, i);
XtOverrideTranslations(
options_button,
XtParseTranslationTable(" <Key> Return: Select()"));
XtManageChild(options_button);
XmStringFree(xmstr);
/*
* tell form that ok_button is the default button...
*/
i = 0;
XtSetArg(argt[i], XmNdefaultButton, ok_button ); i++;
XtSetValues(matte1, argt, i);
/*
* make all buttons *look* the same size...
*/
max_width = max_height = 0;
GetBiggest(ok_button, &max_width, &max_height);
GetBiggest(clear_button, &max_width, &max_height);
GetBiggest(options_button, &max_width, &max_height);
GetBiggest(help_button, &max_width, &max_height);
if ( (int) max_width < MIN_BUTTON_SIZE) max_width = MIN_BUTTON_SIZE;
i = 0;
XtSetArg(argt[i], XmNdefaultButtonShadowThickness, &thick1); i++;
XtSetArg(argt[i], XmNshadowThickness, &thick2); i++;
XtGetValues(ok_button, argt, i);
thick1 *= 4;
thick1 += thick2;
i = 0;
XtSetArg(argt[i], XmNwidth, max_width ); i++;
XtSetArg(argt[i], XmNheight, max_height ); i++;
XtSetArg(argt[i], XmNrecomputeSize, False ); i++;
XtSetArg(argt[i], XmNbottomOffset, thick1 ); i++;
XtSetValues(options_button, argt, i);
i = 0;
XtSetArg(argt[i], XmNwidth, max_width + 2*thick1 ); i++;
XtSetArg(argt[i], XmNheight, max_height + 2*thick1 ); i++;
XtSetArg(argt[i], XmNrecomputeSize, False ); i++;
XtSetValues(ok_button, argt, i);
XtSetValues(clear_button, argt, i);
XtSetValues(help_button, argt, i);
}
/***************************************************************************
*
* MakeDialog
*
* Widgets: error_message, help_message, copyright_msg, hostname_message,
* passwd_message
***************************************************************************/
void
MakeDialog( DialogType dtype )
{
int i, j;
int width;
FILE *fp, *fopen();
char buffer[128];
Widget w = NULL, text;
Dimension txt_width, txt_height;
XmString ok, cancel, nw, sv;
Widget tlev; /* JET - warning, there be dragons here */
unsigned int dpwidth, dpheight, xorg, yorg;
#ifdef VG_TRACE
vg_TRACE_EXECUTION("MakeDialog: entered ...");
#endif /* VG_TRACE */
/*
* do things common to all dialogs...
*/
#ifdef USE_XINERAMA
/* get info on prefered screen */
if (!_DtXineramaGetScreen(dpyinfo.DtXineramaInfo,
appInfo.xineramaPreferredScreen,
&dpwidth, &dpheight, &xorg, &yorg))
{ /* no joy here either - setup for normal */
dpwidth = dpyinfo.width;
dpheight = dpyinfo.height;
xorg = yorg = 0;
}
/* else, should be setup properly */
XWarpPointer(dpyinfo.dpy,None,dpyinfo.root,0,0,0,0,dpwidth/2,dpheight/2);
#else /* no Xinerama */
dpwidth = dpyinfo.width;
dpheight = dpyinfo.height;
xorg = yorg = 0;
#endif
ok = ReadCatalogXms(MC_LABEL_SET, MC_OK_LABEL, MC_DEF_OK_LABEL);
cancel = ReadCatalogXms(MC_LABEL_SET, MC_CANCEL_LABEL, MC_DEF_CANCEL_LABEL);
i = InitArg(MessageBox);
XtSetArg(argt[i], XmNmarginHeight, MBOX_MARGIN_HEIGHT ); i++;
XtSetArg(argt[i], XmNmarginWidth, MBOX_MARGIN_WIDTH ); i++;
XtSetArg(argt[i], XmNshadowThickness, SHADOW_THICKNESS ); i++;
XtSetArg(argt[i], XmNokLabelString, ok ); i++;
XtSetArg(argt[i], XmNcancelLabelString, cancel ); i++;
XtSetArg(argt[i], XmNnoResize, False ); i++;
XtSetArg(argt[i], XmNresizePolicy, XmRESIZE_ANY ); i++;
/*
* create the various dialogs...
*/
/* JET - check the matte widget, and if non-null, well use that as
* the parent for dialogs. Otherwise use table (the original
* toplevel widget for this func). This is useful for Xinerama so
* that child dialogs are centered on the matte, and not the whole
* SLS screen.
*/
if (matte != (Widget)NULL)
tlev = matte;
else
tlev = table;
switch (dtype) {
case error:
xmstr = ReadCatalogXms(MC_ERROR_SET, MC_LOGIN, "");
XtSetArg(argt[i], XmNmessageString, xmstr ); i++;
w = XmCreateErrorDialog(tlev, "error_message", argt, i);
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_HELP_BUTTON));
error_message = w;
break;
case help:
txt_width = (dpwidth > 850) ? 800 : dpwidth - 50;
txt_height = (dpheight > 900) ? 600 : dpheight - 300;
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_HELP_LABEL, MC_DEF_HELP_LABEL);
XtSetArg(argt[i], XmNmessageString, xmstr); i++;
w = XmCreateInformationDialog(tlev, "help_message", argt, i);
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_HELP_BUTTON));
i = InitArg(Text);
XtSetArg(argt[i], XmNheight, txt_height); i++;
XtSetArg(argt[i], XmNwidth, txt_width); i++;
XtSetArg(argt[i], XmNeditMode, XmMULTI_LINE_EDIT); i++;
XtSetArg(argt[i], XmNscrollBarDisplayPolicy, XmAS_NEEDED); i++;
XtSetArg(argt[i], XmNscrollingPolicy, XmAUTOMATIC); i++;
XtSetArg(argt[i], XmNeditable, False); i++;
XtSetArg(
argt[i],
XmNvalue, ReadCatalog(MC_HELP_SET, MC_HELP, MC_DEF_HELP)); i++;
text = XmCreateScrolledText(w, "help_message_text", argt, i);
XtManageChild(text);
XtManageChild(w);
help_message = w;
break;
case copyright:
if ((fp = fopen(COPYRIGHT,"r")) == NULL)
xmstr = XmStringCreate("Cannot open copyright file '/etc/copyright'.",
XmFONTLIST_DEFAULT_TAG);
else {
xmstr = (XmString) NULL;
while (fgets(buffer, 128, fp) != NULL) {
j = strlen(buffer);
if ( buffer[j-1] == '\n' ) buffer[j-1] = '\0';
if ( xmstr != NULL )
xmstr = XmStringConcat(xmstr, XmStringSeparatorCreate());
xmstr = XmStringConcat(xmstr,
XmStringCreate(buffer,
XmFONTLIST_DEFAULT_TAG));
}
fclose(fp);
}
XtSetArg(argt[i], XmNmessageString, xmstr ); i++;
w = XmCreateInformationDialog(tlev, "copyright_msg", argt, i);
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_CANCEL_BUTTON));
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_HELP_BUTTON));
XtAddCallback(w, XmNokCallback, CopyrightCB, (XtPointer) 0);
copyright_msg = w;
break;
case hostname:
nw = ReadCatalogXms(MC_LABEL_SET, MC_NW_LABEL, MC_DEF_NW_LABEL);
sv = ReadCatalogXms(MC_LABEL_SET, MC_START_LABEL, MC_DEF_START_LABEL);
xmstr = ReadCatalogXms(MC_HELP_SET, MC_SYSTEM, MC_DEF_SYSTEM);
XtSetArg(argt[i], XmNmessageString, xmstr ); i++;
XtSetArg(argt[i], XmNokLabelString, nw ); i++;
XtSetArg(argt[i], XmNcancelLabelString, sv ); i++;
w = XmCreateWarningDialog(tlev, "hostname_msg", argt, i);
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_HELP_BUTTON));
XmStringFree(nw);
XmStringFree(sv);
hostname_message = w;
break;
case expassword:
xmstr = ReadCatalogXms(MC_ERROR_SET, MC_PASSWD_EXPIRED,
MC_DEF_PASSWD_EXPIRED);
XtSetArg(argt[i], XmNmessageString, xmstr ); i++;
w = XmCreateQuestionDialog(tlev, "password_msg", argt, i);
XtUnmanageChild(XmMessageBoxGetChild(w,XmDIALOG_HELP_BUTTON));
passwd_message = w;
break;
}
/*
* finish up...
*/
switch (dtype) {
case error:
case hostname:
case expassword:
XtAddCallback(w, XmNokCallback, RespondDialogCB, NULL);
XtAddCallback(w, XmNcancelCallback, RespondDialogCB, NULL);
break;
}
XtSetArg(argt[0], XmNdialogStyle, XmDIALOG_APPLICATION_MODAL ); i++;
if(w) {
XtSetValues(w, argt, 1);
}
XmStringFree(xmstr);
XmStringFree(ok);
XmStringFree(cancel);
/*
* adjust the width of the "ok" button on the dialogs...
*/
width = (dtype == hostname ? FromMM(4000) : MIN_BUTTON_SIZE);
i = 0;
XtSetArg(argt[i], XmNrecomputeSize, False ); i++;
XtSetArg(argt[i], XmNwidth, width ); i++;
XtSetValues(XmMessageBoxGetChild(w, XmDIALOG_OK_BUTTON), argt, i);
}
/***************************************************************************
*
* MakeDtlabel
*
* Widgets: dt_label
***************************************************************************/
static void
MakeDtlabel( void )
{
int i;
#ifdef VG_TRACE
vg_TRACE_EXECUTION("MakeDtlabel: entered ...");
#endif /* VG_TRACE */
i = InitArg(LabelG);
XtSetArg(argt[i], XmNtraversalOn, False ); i++;
XtSetArg(argt[i], XmNtopAttachment, XmATTACH_WIDGET ); i++;
XtSetArg(argt[i], XmNleftAttachment, XmATTACH_FORM ); i++;
XtSetArg(argt[i], XmNrightAttachment, XmATTACH_FORM ); i++;
XtSetArg(argt[i], XmNalignment, XmALIGNMENT_CENTER ); i++;
XtSetArg(argt[i], XmNtopWidget, greeting ); i++;
dt_label = XmCreateLabel(matte1, "dt_label", argt, i);
XtManageChild(dt_label);
}
/***************************************************************************
*
* MakeGreeting
*
* Widgets: greeting
***************************************************************************/
typedef struct {
char *labelString; /* string for label */
char *persLabelString; /* alternate string for label */
XmFontList fontList;
} GreetInfo, *GreetInfoPtr;
static GreetInfo greetInfo;
static XtResource greetResources[] = {
{XmNlabelString, XmCLabelString,
XmRString, sizeof(char *),
XtOffset(GreetInfoPtr, labelString), XtRString, "default" },
{"persLabelString", "PersLabelString",
XmRString, sizeof(char *),
XtOffset(GreetInfoPtr, persLabelString), XtRString, "default" },
{XmNfontList, XmCFontList,
XmRFontList, sizeof(XmFontList),
XtOffset(GreetInfoPtr, fontList), XtRString, NULL }
};
static void
MakeGreeting( void )
{
int i;
char *greetmsg;
char host[128];
char disp[128];
char *p, *q, *s, *t;
int newLine = False;
int skip;
#ifdef VG_TRACE
vg_TRACE_EXECUTION("MakeGreeting: entered ...");
#endif /* VG_TRACE */
/*
* get the user's greeting preferences...
*/
XtGetSubresources(table, &greetInfo, "greeting", "Greeting",
greetResources, XtNumber(greetResources), NULL, 0);
/*
* get the local hostname...
*/
gethostname(host, sizeof (host));
if ( (p = strchr(host,'.')) != NULL )
*p = '\0';
/*
** Get display name (for %DisplayName% substitutions),
** reducing "a.b.c.d:0" constructs to shorter "a:0" form.
*/
strncpy(disp,
dpyinfo.name ? dpyinfo.name : (DisplayString(dpyinfo.dpy)), 127);
disp[127] = '\0';
p = strchr(disp, '.');
t = strchr(disp, ':');
if (p && t) strcpy(p,t);
/*
* use the default string if the user has not specified one...
*/
if ( greetInfo.persLabelString &&
strcmp(greetInfo.persLabelString, "default") == 0 ) {
const char *msg;
msg =
(const char *)
ReadCatalog(MC_LABEL_SET,MC_PERS_GREET_LABEL,MC_DEF_PERS_GREET_LABEL);
greetInfo.persLabelString = strdup(msg);
}
if ( greetInfo.labelString &&
strcmp(greetInfo.labelString, "default") == 0 ) {
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_GREET_LABEL,MC_DEF_GREET_LABEL);
xmstr = XmStringConcat(xmstr,
XmStringCreate(" ", XmFONTLIST_DEFAULT_TAG));
xmstr = XmStringConcat(xmstr,
XmStringCreate(host, XmFONTLIST_DEFAULT_TAG));
}
else {
/*
* scan user's message for %LocalHost% token. Replace with hostname
* if found...
*/
if ( !greetInfo.labelString ||
strlen(greetInfo.labelString) == 0 ||
strcmp(greetInfo.labelString, "None") == 0 ||
strcmp(greetInfo.labelString, "none") == 0 )
greetmsg = strdup(" ");
else {
greetmsg = strdup(greetInfo.labelString);
}
s = greetmsg;
xmstr = (XmString) NULL;
do {
q = s;
/*
* scan for a new line character in remaining label string.
* If found, work with that substring first...
*/
if ( (p = strchr(q, '\n')) != NULL ) {
*p = '\0';
newLine = True;
s = ++p;
if ( *q == '\0' ) /* handle consecutive newlines */
q = " ";
}
else {
newLine = False;
}
/*
* replace all occurrences of %LocalHost% and %DisplayName%
* in the current substring...
*/
while (1) {
p = strstr(q, LOCALHOST);
t = strstr(q, DISPLAYNAME);
if (p && t) { /* both present? do whichever comes first */
if (p > t) p = NULL;
else t = NULL;
}
if (p) { /* replace a %LocalHost% string */
t = host;
skip = sizeof(LOCALHOST);
} else if (t) { /* replace a %DisplayName% string */
p = t;
t = disp;
skip = sizeof(DISPLAYNAME);
} else /* nothing left to replace */
break;
*p = '\0';
xmstr = XmStringConcat(xmstr,
XmStringCreate(q,
XmFONTLIST_DEFAULT_TAG));
xmstr = XmStringConcat(xmstr,
XmStringCreate(t,
XmFONTLIST_DEFAULT_TAG));
q = p + skip - 1;
}
if ( strlen(q) != 0 )
xmstr = XmStringConcat(xmstr,
XmStringCreate(q,
XmFONTLIST_DEFAULT_TAG));
/*
* add a line separator if this is a multi-line greeting...
*/
if ( newLine == True ) {
xmstr = XmStringConcat(xmstr, XmStringSeparatorCreate());
}
} while ( newLine == True ) ;
free(greetmsg);
}
/*
* create the Welcome message...
*/
i = InitArg(LabelG);
XtSetArg(argt[i], XmNtraversalOn, False ); i++;
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
XtSetArg(argt[i], XmNleftAttachment, XmATTACH_FORM); i++;
XtSetArg(argt[i], XmNtopAttachment, XmATTACH_POSITION); i++;
/* XtSetArg(argt[i], XmNtopPosition, 15); i++; */
/* Changed this to accommodate desktop label */
XtSetArg(argt[i], XmNtopPosition, 9); i++;
XtSetArg(argt[i], XmNrightAttachment, XmATTACH_FORM); i++;
/*
* use the user's font if one has been specified, otherwise use
* the application's default...
*/
if ( greetInfo.fontList != NULL ) {
XtSetArg(argt[i], XmNfontList, greetInfo.fontList ); i++;
}
greeting = XmCreateLabel(matte1, "greeting", argt, i);
XtManageChild(greeting);
XmStringFree(xmstr);
}
/***************************************************************************
*
* MakeLogin
*
* Widgets: login_matte,
* login_form, login_label, login_text
***************************************************************************/
static void
MakeLogin( void )
{
int i;
int j;
LoginTextPtr textdata;
XtTranslations textTable;
Widget passwd_text;
String greetstr;
#ifdef VG_TRACE
vg_TRACE_EXECUTION("MakeLogin: entered ...");
#endif /* VG_TRACE */
/*
* create the login form
*/
i = 0;
XtSetArg(argt[i], XmNshadowThickness, 0); i++;
XtSetArg(argt[i], XmNresizable, False ); i++;
XtSetArg(argt[i], XmNleftAttachment, XmATTACH_FORM); i++;
XtSetArg(argt[i], XmNleftOffset, 80); i++;
XtSetArg(argt[i], XmNrightAttachment, XmATTACH_FORM); i++;
XtSetArg(argt[i], XmNrightOffset, 80); i++;
XtSetArg(argt[i], XmNbottomAttachment, XmATTACH_POSITION); i++;
XtSetArg(argt[i], XmNbottomPosition, 65); i++;
/*
XtSetArg(argt[i], XmNresizePolicy, XmRESIZE_ANY); i++;
*/
XtSetArg(argt[i], XmNallowShellResize, True); i++;
login_form = XmCreateForm(matte1, "login_form", argt, i);
XtManageChild(login_form);
/*
* create the login text field...
*/
i = InitArg(Text);
XtSetArg(argt[i], XmNbottomAttachment, XmATTACH_POSITION ); i++;
XtSetArg(argt[i], XmNleftAttachment, XmATTACH_POSITION ); i++;
XtSetArg(argt[i], XmNrightAttachment, XmATTACH_POSITION ); i++;
XtSetArg(argt[i], XmNbottomPosition, 95 ); i++;
XtSetArg(argt[i], XmNrightPosition, 80 ); i++;
XtSetArg(argt[i], XmNleftPosition, 20 ); i++;
XtSetArg(argt[i], XmNselectionArrayCount, 1 ); i++;
XtSetArg(argt[i], XmNmaxLength, 80 ); i++;
XtSetArg(argt[i], XmNmappedWhenManaged, False ); i++;
textdata = malloc(sizeof(LoginText));
XtSetArg(argt[i], XmNuserData, textdata ); i++;
login_text = XmCreateTextField(login_form, "login_text", argt, i);
/*
* From Human Interface model, Tab key operation should work same on
* user field as it does on password field. Password field is setup
* to take Tab key as password data. HIE model is for user field to
* do same.
*/
XtOverrideTranslations(
login_text,
XtParseTranslationTable(
" Shift <Key>Tab: prev-tab-group() \n\
Ctrl <Key>Tab: next-tab-group() "));
XtManageChild(login_text);
#ifdef __hpux
XtAddCallback(login_text, XmNfocusCallback, TextFocusCB, NULL);
#endif
XtAddActions(textActions, 2);
textTable = XtParseTranslationTable(textEventBindings);
#if 0
XtSetArg(argt[i], XmNtranslations, textTable ); i++;
#endif
XtSetArg(argt[i], XmNverifyBell, False ); i++;
passwd_text = XmCreateTextField(login_form, "passwd_text", argt, i);
textdata->bEcho = True;
textdata->noechobuf[0] = '\0';
textdata->text[0] = passwd_text;
textdata->text[1] = login_text;
XtManageChild(passwd_text);
#ifdef __hpux
XtAddCallback(passwd_text, XmNfocusCallback, TextFocusCB, NULL);
#endif
XtAddCallback(passwd_text, XmNmodifyVerifyCallback, EditPasswdCB, NULL);
/*
* Get default greeting string
*/
i = 0;
XtSetArg(argt[i], XmNlabelString, &textdata->onGreeting); i++;
XtGetValues(greeting, argt, i);
textdata->offGreetingFormat = greetInfo.persLabelString;
textdata->offGreetingUname = NULL;
/*
* create the login labels...
*/
i = InitArg(LabelG);
/* modified recomputeSize initial value from False to True, fails
* when setting longer strings. Manifested as bug ID:1200690.
*/
XtSetArg(argt[i], XmNrecomputeSize, True ); i++;
XtSetArg(argt[i], XmNtraversalOn, False ); i++;
XtSetArg(argt[i], XmNbottomAttachment, XmATTACH_WIDGET ); i++;
XtSetArg(argt[i], XmNleftAttachment, XmATTACH_OPPOSITE_WIDGET); i++;
/* XtSetArg(argt[i], XmNleftAttachment, XmATTACH_FORM ); i++;
Commented this statement to align login_label and login_text
XtSetArg(argt[i], XmNrightAttachment, XmATTACH_FORM ); i++;
XtSetArg(argt[i], XmNalignment, XmALIGNMENT_CENTER ); i++;
XtSetArg(argt[i], XmNbottomOffset, 10 ); i++;
*/
XtSetArg(argt[i], XmNleftWidget, login_text ); i++;
XtSetArg(argt[i], XmNbottomWidget, login_text ); i++;
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_LOGIN_LABEL, MC_DEF_LOGIN_LABEL);
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
login_label = XmCreateLabel(login_form, "login_label", argt, i);
XtManageChild(login_label);
XmStringFree(xmstr);
}
/***************************************************************************
*
* MakeOptionsMenu
*
* Widgets: options_menu, options_item[]
***************************************************************************/
void
MakeOptionsMenu( void )
{
int i, j, k;
struct stat statb;
#ifdef VG_TRACE
vg_TRACE_EXECUTION("MakeOptionsMenu: entered ...");
#endif /* VG_TRACE */
/*
* get the built-in pop_up menu from the DtMenuButton...
*/
XtVaGetValues(options_button, DtNsubMenuId, &options_menu, NULL);
/*
* create language cascade menus...
*/
if ( lang_menu == NULL )
MakeLangMenu();
/*
* create first level menu items...
*/
j = 0;
/*
* build [ Language ] menu pane if there are languages to choose from...
*/
if ( lang_menu != NULL ) {
/*
* [ Language ] menu pane...
* attach language cascade menu to this pane
*/
i = InitArg(CascadeBG);
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_LANG_LABEL, MC_DEF_LANG_LABEL);
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
XtSetArg(argt[i], XmNsubMenuId, lang_menu ); i++;
XtSetArg(argt[i], XmNrecomputeSize, True ); i++;
options_item[j] = XmCreateCascadeButtonGadget(options_menu,
"options_languages", argt, i);
XmStringFree(xmstr);
j++;
/*
* separator...
*/
i = InitArg(SeparatorG);
options_item[j] = XmCreateSeparatorGadget(options_menu,
"options_sep2",
argt, i);
j++;
}
if( session_menu == NULL) {
session_menu = XmCreatePulldownMenu(options_menu, "session_menu", NULL, 0);
/*
* [ Dt "Reg" ] menu pane...
*/
i = k = InitArg(ToggleBG);
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_DT_LABEL, MC_DEF_DT_LABEL);
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
XtSetArg(argt[i], XmNrecomputeSize, True ); i++;
XtSetArg(argt[i], XmNuserData, logoInfo.bitmapFile ); i++;
options_dt = XmCreateToggleButtonGadget(session_menu,
"options_dt",
argt, i);
XmStringFree(xmstr);
XtAddCallback(options_dt,
XmNvalueChangedCallback,
MenuItemCB,
(XtPointer) OB_DT);
/*XtManageChild(options_dt); */
/*
* [ Dt Lite ] menu pane...
*/
i = k;
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_DTLITE_LABEL, MC_DEF_DTLITE_LABEL);
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
XtSetArg(argt[i], XmNrecomputeSize, True ); i++;
options_dtlite = XmCreateToggleButtonGadget(session_menu,
"options_dtlite",
argt, i);
XmStringFree(xmstr);
XtAddCallback(options_dtlite,
XmNvalueChangedCallback,
MenuItemCB,
(XtPointer) OB_DTLITE);
}
if ( session_menu != NULL ) {
/*
* [ Language ] menu pane...
* attach language cascade menu to this pane
*/
i = InitArg(CascadeBG);
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_SES_LABEL, MC_DEF_SES_LABEL);
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
XtSetArg(argt[i], XmNsubMenuId, session_menu ); i++;
XtSetArg(argt[i], XmNrecomputeSize, True ); i++;
options_item[j] = XmCreateCascadeButtonGadget(options_menu,
"session_menus", argt, i);
XmStringFree(xmstr);
j++;
/*
* separator...
*/
i = InitArg(SeparatorG);
options_item[j] = XmCreateSeparatorGadget(options_menu, "options_sep1",
argt, i);
j++;
}
/*
* [ No Windows ] menu pane...
*/
i = k = InitArg(PushBG);
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_NW_LABEL, MC_DEF_NW_LABEL);
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
options_item[j] = options_nowindows
= XmCreatePushButtonGadget(options_menu,
"options_noWindows",
argt, i);
XmStringFree(xmstr);
XtAddCallback(options_item[j], XmNactivateCallback,
MenuItemCB, (XtPointer) OB_NO_WINDOWS);
if (getenv(LOCATION) == NULL || strcmp(getenv(LOCATION), "local") != 0 )
XtSetSensitive(options_item[j], False);
j++;
/*
* [ Restart Server ] menu pane...
*/
i = k = InitArg(PushBG);
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_RS_LABEL, MC_DEF_RS_LABEL);
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
options_item[j] = XmCreatePushButtonGadget(options_menu,
"options_restartServer",
argt, i);
XmStringFree(xmstr);
XtAddCallback(options_item[j], XmNactivateCallback,
MenuItemCB, (XtPointer) OB_RESTART_SERVER);
j++;
#ifdef copyright_option
/*
* separator...
*/
i = InitArg(SeparatorG);
options_item[j] = XmCreateSeparatorGadget(options_menu, "options_sep1",
argt, i);
j++;
/*
* [ Copyright ] menu pane...
*/
i = k = InitArg(PushBG);
xmstr = ReadCatalogXms(MC_LABEL_SET, MC_COPY_LABEL, MC_DEF_COPY_LABEL);
XtSetArg(argt[i], XmNlabelString, xmstr ); i++;
options_item[j] = XmCreatePushButtonGadget(options_menu,
"options_copyright",
argt, i);
XmStringFree(xmstr);
XtAddCallback(options_item[j], XmNactivateCallback,
MenuItemCB, (XtPointer) OB_COPYRIGHT);
j++;
#endif
/*
* manage the [Options] menu...
*/
XtManageChildren(options_item, j);
/*
* If the DT Lite Session Manager is not available, remove the DT Lite
* and DT menu panes. The actual widgets must still be created since
* other code (ex. MenuItemCB()) tries to obtain some of their resources.
*/
if ( stat(DTLITESESSION, &statb) != 0 ||
((statb.st_mode & S_IXOTH) != S_IXOTH) ) {
XtUnmanageChild(options_dtlite);
/*
XtUnmanageChild(options_dt);
*/
}
if ( getenv(PINGINTERVAL) != NULL )
XtUnmanageChild(options_nowindows);
}
/***************************************************************************
*
* MyInsert
*
* Local self-insert action for the text widget. The default action
* discards control characters, which are allowed in password.
***************************************************************************/
static void
MyInsert( Widget w, XEvent *event, char **params, Cardinal *num_params )
{
char str[32];
XComposeStatus compstatus;
int n;
n = XLookupString((XKeyEvent *)event, str, sizeof(str),
(KeySym *)NULL, &compstatus);
if (n > 0) {
str[n] = '\0';
XmTextFieldInsert(w, XmTextFieldGetInsertionPosition(w), str);
}
}
/***************************************************************************
*
* MyBackspace
*
* Local backspace action for the text widget.
* Deletes the last character of the password string in the
* widget for each backspace key press, and also does not move the cursor
* position in the widget.
***************************************************************************/
static void
MyBackspace( Widget w, XEvent *event, char **params, Cardinal *num_params )
{
LoginTextPtr textdata;
textdata = GetLoginTextPtr(w);
if (textdata && !textdata->bEcho && (int) strlen(textdata->noechobuf) > 0)
{
textdata->noechobuf[strlen(textdata->noechobuf) - 1] = '\0';
}
}
/***************************************************************************
*
* ErrorHandler
*
* X protocol error handler to override the default
***************************************************************************/
static int
ErrorHandler( Display *dpy, XErrorEvent *event )
{
return 0;
}
/***************************************************************************
*
* xtErrorHandler
*
* Xt protocol error handler to override the default
***************************************************************************/
static void
xtErrorHandler( String msg )
{
LogError((unsigned char *) "%s\n", msg ) ;
exit(NOTIFY_RESTART);
}
/***************************************************************************
*
* xtWarningHandler
*
* Xt protocol error handler to override the default
***************************************************************************/
static void
xtWarningHandler( String msg )
{
LogError( (unsigned char *) "%s\n", msg ) ;
return ;
}
/***************************************************************************
*
* MakeOptionsProc
*
* Timeout routine to build options menu
***************************************************************************/
static void
MakeOptionsProc( XtPointer data, XtIntervalId *id )
{
if (options_menu == NULL)
MakeOptionsMenu();
return;
}
/***************************************************************************
*
* Terminate
*
* Catch a SIGTERM and unmanage display
***************************************************************************/
static SIGVAL
Terminate( int arg )
{
if(-1 == write(1, "terminate", 9)) {
perror(strerror(errno));
}
CleanupAndExit(NULL, NOTIFY_ABORT);
}
/***************************************************************************
*
* DebugWidgetResources
*
* Get widget resources
***************************************************************************/
typedef struct resource_values {
int height;
int width;
int x;
int y;
int rightAttachment;
int leftAttachment;
int topAttachment;
int bottomAttachment;
} ResourceValues;
static void
DebugWidgetResources(Widget w)
{
struct resource_values values;
int i;
i = 0;
bzero((char *) &values, sizeof(values));
XtSetArg(argt[i], XmNheight, &values.height); i++;
XtSetArg(argt[i], XmNwidth, &values.width); i++;
XtSetArg(argt[i], XmNx, &values.x); i++;
XtSetArg(argt[i], XmNy, &values.y); i++;
XtSetArg(argt[i], XmNrightAttachment, &values.rightAttachment); i++;
XtSetArg(argt[i], XmNleftAttachment, &values.leftAttachment); i++;
XtSetArg(argt[i], XmNtopAttachment, &values.topAttachment); i++;
XtSetArg(argt[i], XmNbottomAttachment, &values.bottomAttachment); i++;
XtGetValues(w, argt, i);
}
/***************************************************************************
*
* GetDisplayName (void) - transform the display name into a "short"
* host name that is used to create a display-specific session.
*
* The display name should match one of the following patterns:
*
* 1. host (non-qualified)
* 2. host.domain
* 3. host:n
* 4. host:n.s
* 5. host.domain:n
* 6. host.domain:n.s
*
* Note that 1 and 2 will be used if the display name is actually
* something like unix:0, local:0 or 0:0
*
***************************************************************************/
static char *
GetDisplayName (void)
{
char host[MAXHOSTNAMELEN];
static char tmp[MAXHOSTNAMELEN + 3];
char * pch;
char * col;
char * dot;
pch = XDisplayString(dpyinfo.dpy);
if (!pch ||
!strncmp (pch, "local:0", 7) ||
!strncmp (pch, "unix:0", 6) ||
!strncmp (pch, ":0.0", 4) ||
!strncmp (pch, ":0", 2)) {
gethostname (host, MAXHOSTNAMELEN);
pch = host;
}
col = strchr (pch, ':');
dot = strchr (pch, '.');
if (!col) {
if (dot) {
strncpy (tmp, pch, dot - pch); /* case #2 above */
tmp[dot - pch] = '\000';
} else {
strcpy (tmp, pch); /* case #1 above */
}
} else {
if (!dot || (dot > col)) { /* case #3 and 4 above */
strncpy (tmp, pch, col - pch);
tmp[col - pch] = '\000';
} else { /* case # 5 and 6 above */
strncpy (tmp, pch, dot - pch);
tmp[dot - pch] = '\000';
}
}
strcat (tmp, ":0");
return (tmp);
}
Reference in a new issue View git blame Copy permalink