/* *======================================================================= * * © 2000 Compaq Computer Corporation * * COMPAQ Registered in U.S. Patent and Trademark Office. * * Confidential computer software. Valid license from Compaq required for * possession, use or copying. Consistent with FAR 12.211 and 12.212, Commercial * Computer Software, Computer Software Documentation, and Technical Data for * Commercial Items are licensed to the U.S. Government under vendor's standard * commercial license. * *======================================================================= */ /******************************************************************************/ /* */ /* FACILITY: */ /* */ /* SVN -- Structured Visual Navigation Widget */ /* */ /* ABSTRACT: */ /* */ /* */ /* AUTHORS: */ /* */ /* */ /* CREATION DATE: */ /* */ /* MODIFICATION HISTORY: */ /* */ /* 016 DWD 25-Mar-1999 */ /* On widget recreation, reset editable to False and call a */ /* routine to reset references to the widgets to be reclaimed by */ /* XtDestroyWidget. */ /* 015 A. Napolitano 20-Sep-1990 */ /* Added tests for new Motif mouse semantics, and new callbacks */ /* PopupMenu (MB3) and EntryTransfer (MB2-click). */ /* 013 A. Napolitano 25-Jun-1990 */ /* Changes made so that only compound strings are supported */ /* instead of text strings and compound strings. */ /* 012 S. Lavigne 18-May-1990 */ /* Modify routine SvnDisplayChanged to not call SvnGetDisplayed */ /* if the display count is 0. */ /* 011 A. Napolitano 24-Apr-1990 */ /* Take out code that modified translation table for lhs/rhs */ /* work widgets... */ /* 010 Will Walker 05-Feb-1990 */ /* Add SvnGet{Lhs|Rhs}WorkWidget. This is so applications can */ /* modify the translation table under Motif. */ /* 009 S. Lavigne 01-Feb-1990 */ /* Add #pragma standard lines to compile cleanly with /STAN=PORT.*/ /* 008 Will Walker 26-Jan-1990 */ /* Ultrix compatibility. */ /* 007 Will Walker 25-Jan-1990 */ /* Change DECwWsSvn*.h to DECwMSvn*.h. */ /* 006 Will Walker 23-Jan-1990 */ /* Convert Svn* constants to SvnK*. */ /* 005 Will Walker 23-Jan-1990 */ /* Change SvnSelectEntry to SvnKselectEntry. */ /* 004 SDL 23-Jan-1990 */ /* Change all BCSESVN references to SVN. Change low-level call */ /* BcseSvnCreate to SvnCreateWidget. Change type casting */ /* SvnWidget to Widget. */ /* 003 SDL + WDW 18-Jan-1990 */ /* Modify pulldown menus to use convenience routine */ /* XmCreatePulldownMenu. Re-add map callback to position */ /* pulldown menu. */ /* 002 SDL + WDW 16-Jan-1990 */ /* Make some additional post-converter adjustments to work */ /* under Motif (get rid of the Developer Decisions and Motif */ /* Transition). Fix up the include files, change VoidProc to */ /* XmVoidProc, fix up the high-level widget routines for */ /* creating the main window, menubar, menus and entries. Fix */ /* compound string handling; free compound strings using */ /* XmStringFree instead of XtFree. */ /* 001 S. Lavigne 05-Jan-1990 */ /* Run this module through the Motif converter DXM_PORT.COM */ /* and add a modification history. */ /* */ /* */ /******************************************************************************/ #ifdef VMS /*#pragma nostandard*/ #include "XmP.h" #include "MainW.h" #include "RowColumn.h" #include "CascadeB.h" #include "PushB.h" #include "Shell.h" /*#pragma standard*/ #else #include #include #include #include #include #include #endif #include "DXmSvn.h" #ifdef VMS #include "stdio.h" #else #include #endif #include /*********************************************************/ /* Make reference to Source module defined information */ /*********************************************************/ /* ** Routine that tells us that we are on an expandable/collapsable node */ extern Boolean SourceIsNodeParent (); /* ** Routines to open/close/toggle an expandable entry */ extern void SourceToggleNode (); extern void SourceOpenNode (); extern void SourceCloseNode (); extern void SourceToggleEditable (); /* ** Callback routines inplemented in the source module */ extern XtCallbackRec SvnAttachCB [2]; extern XtCallbackRec SvnDetachCB [2]; extern XtCallbackRec SvnGetEntryCB [2]; /* ** Integer maintained by the source module */ extern int SourceNumEntries; extern int SourceNumComps; extern int Editable; /* ** Forward routine declarations for SVN callbacks */ void SvnConfirmed (); void SvnExtended (); void SvnSelected (); void SvnUnselected (); void SvnTransitionsDone (); void SvnDisplayChanged (); void SvnHelpRoutine (); void SvnHelpRoutine2 (); void SvnDragged (); void SvnDragging (); void SvnDraggingEnd (); void SvnEntryTransfer (); void SvnPopupMenu (); /* ** Forward routine declarations for menu callbacks */ void MenuQuit (); void MenuExpandAll (); void MenuHighlightToggle (); void highlight_entry (); void toggle_highlight (); void MenuToggleDisplay (); void MenuToggleSelectMode (); void MenuToggleEditable (); void MenuToggleLineStyle (); void MenuToggleCentered (); void MenuTopTreeStyle (); void MenuToggleArcs (); void MenuToggleShadows (); void MenuToggleOutlines (); void MenuToggleFixed (); void MenuToggleTruncate (); void MenuToggleShowing3 (); void MenuToggleShowing4 (); void MenuToggleShowing5 (); void MenuLeftTreeStyle (); void MenuOutlineTreeStyle (); void MenuUserDefTreeStyle (); void MenuSelectAll (); void MenuHighlightAll (); void MenuToggleSelections (); void MenuClearSelections (); void MenuClearHighlight (); void MenuPosition (); void SetPositionMenuSens (); void MenuSetSensitivity (); void MenuRecreate (); void LclCreateSvn (); Widget LclFindSvnWidget (); /* ** XtCallbackRec structures for SVN callbacks */ XtCallbackRec SvnConfirmedCB [2] = {(XmVoidProc)SvnConfirmed ,NULL}; XtCallbackRec SvnExtendedCB [2] = {(XmVoidProc)SvnExtended ,NULL}; XtCallbackRec SvnSelectedCB [2] = {(XmVoidProc)SvnSelected ,NULL}; XtCallbackRec SvnUnselectedCB [2] = {(XmVoidProc)SvnUnselected ,NULL}; XtCallbackRec SvnTransitionsDoneCB [2] = {(XmVoidProc)SvnTransitionsDone ,NULL}; XtCallbackRec SvnDisplayChangedCB [2] = {(XmVoidProc)SvnDisplayChanged ,NULL}; XtCallbackRec SvnHelpRoutineCB [2] = {(XmVoidProc)SvnHelpRoutine ,NULL}; XtCallbackRec SvnHelpRoutineCB2 [2] = {(XmVoidProc)SvnHelpRoutine2 ,NULL}; XtCallbackRec SvnDraggedCB [2] = {(XmVoidProc)SvnDragged ,NULL}; XtCallbackRec SvnDraggingCB [2] = {(XmVoidProc)SvnDragging ,NULL}; XtCallbackRec SvnDraggingEndCB [2] = {(XmVoidProc)SvnDraggingEnd ,NULL}; XtCallbackRec SvnEntryTransferCB [2] = {(XmVoidProc)SvnEntryTransfer ,NULL}; XtCallbackRec SvnPopupMenuCB [2] = {(XmVoidProc)SvnPopupMenu ,NULL}; /* ** Callbacks for menu picks */ XtCallbackRec MenuQuitCB [2] = {(XmVoidProc)MenuQuit ,NULL}; XtCallbackRec MenuExpandAllCB [2] = {(XmVoidProc)MenuExpandAll ,NULL}; XtCallbackRec MenuToggleHighlightCB [2] = {(XmVoidProc)MenuHighlightToggle ,NULL}; XtCallbackRec MenuDisplayTreeCB [2] = {(XmVoidProc)MenuToggleDisplay ,(caddr_t)DXmSvnKdisplayTree}; XtCallbackRec MenuDisplayOutlineCB [2] = {(XmVoidProc)MenuToggleDisplay ,(caddr_t)DXmSvnKdisplayOutline}; XtCallbackRec MenuDisplayColumnsCB [2] = {(XmVoidProc)MenuToggleDisplay ,(caddr_t)DXmSvnKdisplayColumns}; XtCallbackRec MenuSelectModeEntryCB [2] = {(XmVoidProc)MenuToggleSelectMode ,(caddr_t)DXmSvnKselectEntry}; XtCallbackRec MenuSelectModeCompCB [2] = {(XmVoidProc)MenuToggleSelectMode ,(caddr_t)DXmSvnKselectComp}; XtCallbackRec MenuSelectModeCompAndLhsCB [2] = {(XmVoidProc)MenuToggleSelectMode ,(caddr_t)DXmSvnKselectCompAndPrimary}; XtCallbackRec MenuSelectModeEntryOrCompCB [2] = {(XmVoidProc)MenuToggleSelectMode ,(caddr_t)DXmSvnKselectEntryOrComp}; XtCallbackRec MenuToggleEditableCB [2] = {(XmVoidProc)MenuToggleEditable ,NULL}; XtCallbackRec MenuToggleLineStyleCB [2] = {(XmVoidProc)MenuToggleLineStyle ,NULL}; XtCallbackRec MenuToggleCenteredCB [2] = {(XmVoidProc)MenuToggleCentered ,NULL}; XtCallbackRec MenuToggleArcsCB [2] = {(XmVoidProc)MenuToggleArcs ,NULL}; XtCallbackRec MenuToggleShadowsCB [2] = {(XmVoidProc)MenuToggleShadows ,NULL}; XtCallbackRec MenuToggleOutlinesCB [2] = {(XmVoidProc)MenuToggleOutlines ,NULL}; XtCallbackRec MenuTopTreeStyleCB [2] = {(XmVoidProc)MenuTopTreeStyle ,NULL}; XtCallbackRec MenuOutlineTreeStyleCB [2] = {(XmVoidProc)MenuOutlineTreeStyle ,NULL}; XtCallbackRec MenuLeftTreeStyleCB [2] = {(XmVoidProc)MenuLeftTreeStyle ,NULL}; XtCallbackRec MenuUserDefTreeStyleCB [2] = {(XmVoidProc)MenuUserDefTreeStyle ,NULL}; XtCallbackRec MenuToggleSelectionsCB [2] = {(XmVoidProc)MenuToggleSelections ,NULL}; XtCallbackRec MenuSelectAllCB [2] = {(XmVoidProc)MenuSelectAll ,NULL}; XtCallbackRec MenuHighlightAllCB [2] = {(XmVoidProc)MenuHighlightAll ,NULL}; XtCallbackRec MenuClearSelectionsCB [2] = {(XmVoidProc)MenuClearSelections ,NULL}; XtCallbackRec MenuClearHighlightCB [2] = {(XmVoidProc)MenuClearHighlight ,NULL}; XtCallbackRec MenuPositionTopCB [2] = {(XmVoidProc)MenuPosition ,(caddr_t)DXmSvnKpositionTop}; XtCallbackRec MenuPositionMiddleCB [2] = {(XmVoidProc)MenuPosition ,(caddr_t)DXmSvnKpositionMiddle}; XtCallbackRec MenuPositionBottomCB [2] = {(XmVoidProc)MenuPosition ,(caddr_t)DXmSvnKpositionBottom}; XtCallbackRec MenuPositionPrevPageCB [2] = {(XmVoidProc)MenuPosition ,(caddr_t)DXmSvnKpositionPreviousPage}; XtCallbackRec MenuPositionNextPageCB [2] = {(XmVoidProc)MenuPosition ,(caddr_t)DXmSvnKpositionNextPage}; XtCallbackRec SetPositionMenuSensCB [2] = {(XmVoidProc)SetPositionMenuSens ,NULL}; XtCallbackRec MenuToggleFixedCB [2] = {(XmVoidProc)MenuToggleFixed ,NULL}; XtCallbackRec MenuToggleTruncateCB [2] = {(XmVoidProc)MenuToggleTruncate ,NULL}; XtCallbackRec MenuToggleShowing3CB [2] = {(XmVoidProc)MenuToggleShowing3 ,NULL}; XtCallbackRec MenuToggleShowing4CB [2] = {(XmVoidProc)MenuToggleShowing4 ,NULL}; XtCallbackRec MenuToggleShowing5CB [2] = {(XmVoidProc)MenuToggleShowing5 ,NULL}; XtCallbackRec MenuSetInsensitiveCB [2] = {(XmVoidProc)MenuSetSensitivity ,(caddr_t)0}; XtCallbackRec MenuSetAllSensitiveCB [2] = {(XmVoidProc)MenuSetSensitivity ,(caddr_t)1}; XtCallbackRec MenuSetSvnInsensitiveCB [2] = {(XmVoidProc)MenuSetSensitivity ,(caddr_t)2}; XtCallbackRec MenuSetSvnSensitiveCB [2] = {(XmVoidProc)MenuSetSensitivity ,(caddr_t)3}; XtCallbackRec MenuRecreateCB [2] = {(XmVoidProc)MenuRecreate ,NULL}; /* ** Test Program widgets */ Widget Svn; Widget toplevel; Widget mainwindow; Widget menubar; Widget filePulldown; Widget expandAllEntry; Widget displayModePulldown; Widget displayOutEntry; Widget displayTreeEntry; Widget displayColEntry; Widget selectionModePulldown; Widget selectEntry; Widget selectCompEntry; Widget selectPrimaryEntry; Widget selectOrCompEntry; Widget editableEntry; Widget makeSensitiveEntry; Widget makeInsensitiveEntry; Widget makeSVNInsensitiveEntry; Widget makeSVNSensitiveEntry; Widget recreateEntry; Widget quitEntry; Widget treePulldown; Widget treeStylePulldown; Widget topEntry; Widget leftEntry; Widget outlineEntry; Widget UserDefbutton; Widget lineStyleEntry; Widget shadowsEntry; Widget centeredEntry; Widget arcsEntry; Widget outlinesEntry; Widget functionsPulldown; Widget toggleSelectionsEntry; Widget toggleHighlightEntry; Widget toggleFixedEntry; Widget toggleTruncateEntry; Widget toggleShowing3; Widget toggleShowing4; Widget toggleShowing5; Widget positionPulldown; Widget positionTopEntry; Widget positionMiddleEntry; Widget positionBottomEntry; Widget positionPrevPageEntry; Widget positionNextPageEntry; /* ** Variable which can be set in the debugger to turn off printf statements */ Boolean announce = TRUE; Boolean announce_display = FALSE; /* ** General state variables */ Boolean show_highlighting = FALSE; Boolean show_selections = TRUE; Boolean centered_components; Boolean perpendicular_lines; Boolean shadows; Boolean outlines; Boolean arc_width; Boolean fixed_width_entries; Boolean truncate_text; Boolean showing_3; Boolean showing_4; Boolean showing_5; int display_mode = DXmSvnKdisplayOutline; XmFontList fontlist; /* ** Now for the main routine */ int main (argc, argv) unsigned int argc; char **argv; { /* ** Arguments for the widgets */ Arg al[20]; /* Argument list */ int ac = 0; /* Argument count */ Arg arguments[20]; int menubar_height; int svn_height; XmString cs; /* ** Toolkit initialization */ toplevel = XtInitialize ("svn", "svn", NULL, 0, &argc, argv); /* ** Tell the top level widget to allow its children to resize */ XtSetArg (arguments[0], XtNallowShellResize, TRUE); XtSetValues (toplevel, arguments, 1); /* ** Create the main window */ ac = 0; XtSetArg(al[ac], XmNx, 0); ac++; XtSetArg(al[ac], XmNy, 0); ac++; XtSetArg(al[ac], XmNwidth, 512); ac++; XtSetArg(al[ac], XmNheight, 0); ac++; mainwindow = XmCreateMainWindow(toplevel, "SvnTest", al, ac); XtManageChild (mainwindow); /* ** Create the menu bar */ ac = 0; XtSetArg(al[ac], XmNentryCallback, NULL); ac++; XtSetArg(al[ac], XmNhelpCallback, NULL); ac++; menubar = XmCreateMenuBar(mainwindow, "menubar", al, ac); XtManageChild (menubar); /* ** Create the SVN widget */ LclCreateSvn (); /* ** Create the file Pulldown menu. This is not a managed child... */ ac = 0; XtSetArg(al[ac], XmNorientation, XmVERTICAL); ac++; filePulldown = XmCreatePulldownMenu(menubar, "", al, ac); /* ** Create the Entry */ ac = 0; XtSetArg(al[ac], XmNlabelString, XmStringCreate("File", XmSTRING_DEFAULT_CHARSET)); ac++; XtSetArg(al[ac], XmNsubMenuId, filePulldown); ac++; XtManageChild(XmCreateCascadeButton(menubar, "", al, ac)); /* ** Make pushbuttons inside of the menu (create the Expand All button). */ ac = 0; cs = XmStringCreate("Expand All", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuExpandAllCB); ac++; expandAllEntry = XmCreatePushButton(filePulldown, "", al, ac); XtManageChild (expandAllEntry); XmStringFree (cs); /* ** Create the DXmSvnNdisplayMode Pulldown menu. This is not a managed child... */ ac = 0; XtSetArg(al[ac], XmNorientation, XmVERTICAL); ac++; displayModePulldown = XmCreatePulldownMenu(filePulldown, "", al, ac); /* ** Create the Entry and the pushbuttons for the displayMode submenu */ ac = 0; XtSetArg(al[ac], XmNlabelString, XmStringCreate("DXmSvnNdisplayMode", XmSTRING_DEFAULT_CHARSET)); ac++; XtSetArg(al[ac], XmNsubMenuId, displayModePulldown); ac++; XtManageChild(XmCreateCascadeButton(filePulldown, "", al, ac)); ac = 0; cs = XmStringCreate("DXmSvnKdisplayOutline", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuDisplayOutlineCB); ac++; displayOutEntry = XmCreatePushButton(displayModePulldown, "", al, ac); XtManageChild (displayOutEntry); XmStringFree (cs); ac = 0; cs = XmStringCreate("DXmSvnKdisplayTree", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuDisplayTreeCB); ac++; displayTreeEntry = XmCreatePushButton(displayModePulldown, "", al, ac); XtManageChild (displayTreeEntry); XmStringFree (cs); ac = 0; cs = XmStringCreate("DXmSvnKdisplayColumns", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuDisplayColumnsCB); ac++; displayColEntry = XmCreatePushButton(displayModePulldown, "", al, ac); XtManageChild (displayColEntry); XmStringFree (cs); /* ** Create the DXmSvnNselectionMode Pulldown menu. This is not a managed child... */ ac = 0; XtSetArg(al[ac], XmNorientation, XmVERTICAL); ac++; selectionModePulldown = XmCreatePulldownMenu(filePulldown, "", al, ac); /* ** Create the Entry and the pushbuttons for the selectionMode submenu */ ac = 0; XtSetArg(al[ac], XmNlabelString, XmStringCreate("DXmSvnNselectionMode", XmSTRING_DEFAULT_CHARSET)); ac++; XtSetArg(al[ac], XmNsubMenuId, selectionModePulldown); ac++; XtManageChild(XmCreateCascadeButton(filePulldown, "", al, ac)); ac = 0; cs = XmStringCreate("DXmSvnKselectEntry", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuSelectModeEntryCB); ac++; selectEntry = XmCreatePushButton(selectionModePulldown, "", al, ac); XtManageChild (selectEntry); XmStringFree (cs); ac = 0; cs = XmStringCreate("DXmSvnKselectComp", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuSelectModeCompCB); ac++; selectCompEntry = XmCreatePushButton(selectionModePulldown, "", al, ac); XtManageChild (selectCompEntry); XmStringFree (cs); ac = 0; cs = XmStringCreate("DXmSvnKselectCompAndPrimary", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuSelectModeCompAndLhsCB); ac++; selectPrimaryEntry = XmCreatePushButton(selectionModePulldown, "", al, ac); XtManageChild (selectPrimaryEntry); XmStringFree (cs); ac = 0; cs = XmStringCreate("DXmSvnKselectEntryOrComp", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuSelectModeEntryOrCompCB); ac++; selectOrCompEntry = XmCreatePushButton(selectionModePulldown, "", al, ac); XtManageChild (selectOrCompEntry); XmStringFree (cs); /* ** Set up Editable/Non-editable text button */ ac = 0; cs = XmStringCreate("Editable Text", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleEditableCB); ac++; editableEntry = XmCreatePushButton(filePulldown, "", al, ac); XtManageChild (editableEntry); XmStringFree (cs); /* ** Entry for setting the sensitivity */ ac = 0; cs = XmStringCreate("Make All Sensitive", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuSetAllSensitiveCB); ac++; makeSensitiveEntry = XmCreatePushButton(filePulldown, "", al, ac); XtManageChild (makeSensitiveEntry); XmStringFree (cs); /* ** Entry for setting the insensitivity */ ac = 0; cs = XmStringCreate("Make Insensitive", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuSetInsensitiveCB); ac++; makeInsensitiveEntry = XmCreatePushButton(filePulldown, "", al, ac); XtManageChild (makeInsensitiveEntry); XmStringFree (cs); ac = 0; cs = XmStringCreate("Make SVN Insensitive", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuSetSvnInsensitiveCB); ac++; makeSVNInsensitiveEntry = XmCreatePushButton(filePulldown, "", al, ac); XtManageChild (makeSVNInsensitiveEntry); XmStringFree (cs); ac = 0; cs = XmStringCreate("Make SVN Sensitive", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuSetSvnSensitiveCB); ac++; makeSVNSensitiveEntry = XmCreatePushButton(filePulldown, "", al, ac); XtManageChild (makeSVNSensitiveEntry); XmStringFree (cs); /* ** Entry for Recreating widget */ ac = 0; cs = XmStringCreate("Recreate", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuRecreateCB); ac++; recreateEntry = XmCreatePushButton(filePulldown, "", al, ac); XtManageChild (recreateEntry); XmStringFree (cs); /* ** Quit button */ ac = 0; cs = XmStringCreate("Quit", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuQuitCB); ac++; quitEntry = XmCreatePushButton(filePulldown, "", al, ac); XtManageChild (quitEntry); XmStringFree (cs); /* ** Create the tree Pulldown menu. This is not a managed child... */ ac = 0; XtSetArg(al[ac], XmNorientation, XmVERTICAL); ac++; treePulldown = XmCreatePulldownMenu(menubar, "", al, ac); /* ** Create the Entry */ ac = 0; XtSetArg(al[ac], XmNlabelString, XmStringCreate("Tree", XmSTRING_DEFAULT_CHARSET)); ac++; XtSetArg(al[ac], XmNsubMenuId, treePulldown); ac++; XtManageChild(XmCreateCascadeButton(menubar, "", al, ac)); /* ** Create the tree Style Pulldown menu. This is not a managed child... */ ac = 0; XtSetArg(al[ac], XmNorientation, XmVERTICAL); ac++; treeStylePulldown = XmCreatePulldownMenu(treePulldown, "", al, ac); /* ** Create the Entry */ ac = 0; XtSetArg(al[ac], XmNlabelString, XmStringCreate("Tree Style", XmSTRING_DEFAULT_CHARSET)); ac++; XtSetArg(al[ac], XmNsubMenuId, treeStylePulldown); ac++; XtManageChild(XmCreateCascadeButton(treePulldown, "", al, ac)); /* ** Create the buttons in the "Tree Style" submenu */ ac = 0; cs = XmStringCreate("Top", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuTopTreeStyleCB); ac++; topEntry = XmCreatePushButton(treeStylePulldown, "", al, ac); XtManageChild (topEntry); XmStringFree (cs); ac = 0; cs = XmStringCreate("Left", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuLeftTreeStyleCB); ac++; leftEntry = XmCreatePushButton(treeStylePulldown, "", al, ac); XtManageChild (leftEntry); XmStringFree (cs); ac = 0; cs = XmStringCreate("Outline", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuOutlineTreeStyleCB); ac++; outlineEntry = XmCreatePushButton(treeStylePulldown, "", al, ac); XtManageChild (outlineEntry); XmStringFree (cs); ac = 0; cs = XmStringCreate("User Defined", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuUserDefTreeStyleCB); ac++; UserDefbutton = XmCreatePushButton(treeStylePulldown, "", al, ac); XtManageChild (UserDefbutton); XmStringFree (cs); /* ** Entry for line Style */ ac = 0; if (perpendicular_lines) cs = XmStringCreate("Diagonal Lines", XmSTRING_DEFAULT_CHARSET); else cs = XmStringCreate("Perpendicular Lines", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleLineStyleCB); ac++; lineStyleEntry = XmCreatePushButton(treePulldown, "", al, ac); XtManageChild (lineStyleEntry); XmStringFree (cs); /* ** Entry to add/remove shadows */ ac = 0; if (shadows) cs = XmStringCreate("Remove Shadows", XmSTRING_DEFAULT_CHARSET); else cs = XmStringCreate("Add Shadows", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleShadowsCB); ac++; shadowsEntry = XmCreatePushButton(treePulldown, "", al, ac); XtManageChild (shadowsEntry); XmStringFree (cs); /* ** Entry to center/uncenter components */ ac = 0; if (centered_components) cs = XmStringCreate("Normal Components", XmSTRING_DEFAULT_CHARSET); else cs = XmStringCreate("Center Components", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleCenteredCB); ac++; centeredEntry = XmCreatePushButton(treePulldown, "", al, ac); XtManageChild (centeredEntry); XmStringFree (cs); /* ** Entry to add/remove arcs */ ac = 0; if (arc_width == 0) cs = XmStringCreate("Oval Entries", XmSTRING_DEFAULT_CHARSET); else cs = XmStringCreate("Rectangular Entries", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleArcsCB); ac++; arcsEntry = XmCreatePushButton(treePulldown, "", al, ac); XtManageChild (arcsEntry); XmStringFree (cs); /* ** Entry to center components */ ac = 0; if (outlines) cs = XmStringCreate("Remove Outlines", XmSTRING_DEFAULT_CHARSET); else cs = XmStringCreate("Add Outlines", XmSTRING_DEFAULT_CHARSET); XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleOutlinesCB); ac++; outlinesEntry = XmCreatePushButton(treePulldown, "", al, ac); XtManageChild (outlinesEntry); XmStringFree (cs); /* ** Create the Functions Pulldown menu. This is not a managed child... */ ac = 0; XtSetArg(al[ac], XmNorientation, XmVERTICAL); ac++; functionsPulldown = XmCreatePulldownMenu(menubar, "", al, ac); /* ** Create the Entry */ ac = 0; XtSetArg(al[ac], XmNlabelString, XmStringCreate("Functions", XmSTRING_DEFAULT_CHARSET)); ac++; XtSetArg(al[ac], XmNsubMenuId, functionsPulldown); ac++; XtManageChild(XmCreateCascadeButton(menubar, "", al, ac)); /* ** Entry for Show/Hide Highlighting */ cs = XmStringCreate("Show Highlight", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleHighlightCB); ac++; toggleHighlightEntry = XmCreatePushButton(functionsPulldown, "", al, ac); XmStringFree(cs); XtManageChild (toggleHighlightEntry); /* ** Entry for Show/Hide selections */ cs = XmStringCreate("Hide Selections", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleSelectionsCB); ac++; toggleSelectionsEntry = XmCreatePushButton(functionsPulldown, "", al, ac); XmStringFree(cs); XtManageChild (toggleSelectionsEntry); /* ** Entry for Select All */ cs = XmStringCreate("Select All", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuSelectAllCB); ac++; XtManageChild(XmCreatePushButton(functionsPulldown, "", al, ac)); XmStringFree(cs); /* ** Entry for Highlight All */ cs = XmStringCreate("Highlight All", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuHighlightAllCB); ac++; XtManageChild(XmCreatePushButton(functionsPulldown, "", al, ac)); XmStringFree(cs); /* ** Entry for Clear Selections */ cs = XmStringCreate("Clear Selections", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuClearSelectionsCB); ac++; XtManageChild(XmCreatePushButton(functionsPulldown, "", al, ac)); XmStringFree(cs); /* ** Entry for Clear Highlighting */ cs = XmStringCreate("Clear Highlighting", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuClearHighlightCB); ac++; XtManageChild(XmCreatePushButton(functionsPulldown, "", al, ac)); XmStringFree(cs); /* ** Entry for Fixed Width entries */ if (fixed_width_entries) cs = XmStringCreate("Variable Width Entries", XmSTRING_DEFAULT_CHARSET); else cs = XmStringCreate("Fixed Width Entries", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleFixedCB); ac++; toggleFixedEntry = XmCreatePushButton(functionsPulldown, "", al, ac); XmStringFree(cs); XtManageChild (toggleFixedEntry); /* ** Entry for truncating text */ if (truncate_text) cs = XmStringCreate("Overflow Text", XmSTRING_DEFAULT_CHARSET); else cs = XmStringCreate("Truncate Text", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleTruncateCB); ac++; toggleTruncateEntry = XmCreatePushButton(functionsPulldown, "", al, ac); XmStringFree(cs); XtManageChild (toggleTruncateEntry); /* ** Entry for showing component 3 */ if (showing_3) cs = XmStringCreate("Remove Component 3", XmSTRING_DEFAULT_CHARSET); else cs = XmStringCreate("Insert Component 3", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleShowing3CB); ac++; toggleShowing3 = XmCreatePushButton(functionsPulldown, "", al, ac); XmStringFree(cs); XtManageChild (toggleShowing3); /* ** Entry for showing component 4 */ if (showing_4) cs = XmStringCreate("Remove Component 4", XmSTRING_DEFAULT_CHARSET); else cs = XmStringCreate("Insert Component 4", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleShowing4CB); ac++; toggleShowing4 = XmCreatePushButton(functionsPulldown, "", al, ac); XmStringFree(cs); XtManageChild (toggleShowing4); /* ** Entry for showing component 5 */ if (showing_5) cs = XmStringCreate("Remove Component 5", XmSTRING_DEFAULT_CHARSET); else cs = XmStringCreate("Insert Component 5", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuToggleShowing5CB); ac++; toggleShowing5 = XmCreatePushButton(functionsPulldown, "", al, ac); XmStringFree(cs); XtManageChild (toggleShowing5); /* ** Create the Position Pulldown menu. This is not a managed child... */ ac = 0; XtSetArg(al[ac], XmNorientation, XmVERTICAL); ac++; XtSetArg(al[ac], XmNmapCallback, SetPositionMenuSensCB); ac++; positionPulldown = XmCreatePulldownMenu(menubar, "", al, ac); /* ** Create the Entry */ ac = 0; XtSetArg(al[ac], XmNlabelString, XmStringCreate("Position", XmSTRING_DEFAULT_CHARSET)); ac++; XtSetArg(al[ac], XmNsubMenuId, positionPulldown); ac++; XtManageChild(XmCreateCascadeButton(menubar, "", al, ac)); /* ** Entry for position top */ cs = XmStringCreate("Top", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuPositionTopCB); ac++; positionTopEntry = XmCreatePushButton(positionPulldown, "", al, ac); XmStringFree(cs); XtManageChild(positionTopEntry); /* ** Entry for position middle */ cs = XmStringCreate("Middle", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuPositionMiddleCB); ac++; positionMiddleEntry = XmCreatePushButton(positionPulldown, "", al, ac); XmStringFree(cs); XtManageChild(positionMiddleEntry); /* ** Entry for position bottom */ cs = XmStringCreate("Bottom", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuPositionBottomCB); ac++; positionBottomEntry = XmCreatePushButton(positionPulldown, "", al, ac); XmStringFree(cs); XtManageChild(positionBottomEntry); /* ** Entry for position previous page */ cs = XmStringCreate("Previous Page", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuPositionPrevPageCB); ac++; positionPrevPageEntry = XmCreatePushButton(positionPulldown, "", al, ac); XmStringFree(cs); XtManageChild(positionPrevPageEntry); /* ** Entry for position next page */ cs = XmStringCreate("Next Page", XmSTRING_DEFAULT_CHARSET); ac = 0; XtSetArg(al[ac], XmNlabelString, cs); ac++; XtSetArg(al[ac], XmNactivateCallback, MenuPositionNextPageCB); ac++; positionNextPageEntry = XmCreatePushButton(positionPulldown, "", al, ac); XmStringFree(cs); XtManageChild(positionNextPageEntry); /* ** Recompute the height of the mainwindow to be the height of the menubar ** plus the height of the svn widget. */ XtSetArg (arguments[0], XmNheight, &menubar_height); XtGetValues (menubar, arguments, 1); XtSetArg (arguments[0], XmNheight, &svn_height); XtGetValues (Svn, arguments, 1); XtSetArg (arguments[0], XmNheight, menubar_height + svn_height + 10); XtSetValues (mainwindow, arguments, 1); /* ** Set the areas */ XmMainWindowSetAreas(mainwindow,menubar,NULL,NULL,NULL,Svn); /* ** Realize the widgets */ XtRealizeWidget (toplevel); /* ** Cycle on the events */ XtMainLoop(); /* ** Never gets here... */ return (0); } /* ** SelectAndConfirm callback routine. This routine is called when one and ** only one Entry is selected. The Entry number selected is provided in the ** callback structure. */ void SvnConfirmed (w, unused_tag, data) Widget w; int unused_tag; DXmSvnCallbackStruct *data; { /* ** Announce the routine on the debugging terminal */ if (announce) printf ("SelectAndConfirm handler\n"); /* ** Determine if the Entry can be expanded. If so, then tell the source module ** to deal with it. */ if (SourceIsNodeParent (data->entry_number, data->entry_tag) == TRUE) { SourceToggleNode (data->entry_number, data->entry_tag); DXmSvnClearSelection (w, data->entry_number); }; } /* ** ExtendConfirm callback routine. This only tells us that things were ** selected. It does not tell us which ones. We must make a call to the ** get selections and get number of selections routines to determine this. */ void SvnExtended (w) Widget w; { /* ** Local data declarations */ int number_selected; int selections [50]; int Entry_tags [50]; int i; /* ** Announce the routine on the debugging terminal */ if (announce) printf ("ExtendConfirm handler\n"); /* ** Ask how many were selected. */ number_selected = DXmSvnGetNumSelections (w); /* ** Get those that are selected */ DXmSvnGetSelections (w, selections, NULL, Entry_tags, number_selected); /* ** For each Entry, determine if can be expanded. If so, then tell the ** source module to deal with it. Go through the list backwards in order ** not to throw off the Entry numbers. */ for (i = number_selected; i > 0; i--) if (SourceIsNodeParent (selections[i-1], Entry_tags[i-1]) == TRUE) { SourceToggleNode (selections[i-1], Entry_tags[i-1]); DXmSvnClearSelection (w, selections[i-1]); }; } /* ** This routine is called whenever an Entry transitions from the unselected ** to the selected state. If I wanted to keep track of which ones were ** selected, I would do it here. */ void SvnSelected (unused_w, unused_tag, data) Widget unused_w; int unused_tag; DXmSvnCallbackStruct *data; { /* ** Announce the routine on the debugging terminal */ if (announce) printf ("EntrySelected handler - Entry_number = %d, component = %d, first = %d\n", data->entry_number, data->component_number, data->first_selection); } /* ** This routine is called whenever an Entry transitions from the selected ** to the unselected state. If I wanted to keep track of which ones were ** selected, I would do it here. */ void SvnUnselected (unused_w, unused_tag, data) Widget unused_w; int unused_tag; DXmSvnCallbackStruct *data; { /* ** Announce the routine on the debugging terminal */ if (announce) printf ("EntryUnselected handler - Entry_number = %d\n", data->entry_number); } /* ** This routine is called whenever all of a set of transitions have been done. */ void SvnTransitionsDone (unused_w) Widget unused_w; { /* ** Announce the routine on the debugging terminal */ if (announce) printf ("TransitionsDone handler\n"); } /* ** This routine is called whenever the set of displayed entries is changed. */ void SvnDisplayChanged (w, unused_tag, unused_data) Widget w; int unused_tag; DXmSvnCallbackStruct *unused_data; { /* ** Local data declarations */ int disp_count; int disp_nums [75]; int disp_ys [75]; int i; /* ** Announce the routine on the debugging terminal */ if (announce) printf ("DisplayChanged handler\n"); /* ** Ask how many are being displayed. If none are being displayed, then ** leave. */ disp_count = DXmSvnGetNumDisplayed (w); if (disp_count == 0) return; /* ** Max out at 75 hardcoded */ if (disp_count > 75) disp_count = 75; /* ** Get those that are displayed. The null field is for a tag array. */ DXmSvnGetDisplayed (w, disp_nums, NULL, disp_ys, disp_count); /* ** For each entry being displayed, show the information. */ if (announce_display) for (i = 0; i < disp_count; i++) printf (" Entry %d displayed at %d\n", disp_nums[i], disp_ys[i]); } /* ** This routine is called whenever a group of entries have be drugged. */ void SvnDragged (unused_w, unused_tag, data) Widget unused_w; int unused_tag; DXmSvnCallbackStruct *data; { /* ** Local data declarations */ Arg arguments [10]; Position offset_x, offset_y; short tree_style = 0; int num_selections,i; int selection[1]; int entry_tags[1]; /* ** Announce the routine on the debugging terminal */ if (announce) printf ("SelectionsDragged handler - to Entry_number = %d, component = %d, Transfer Mode %d\n", data->entry_number, data->component_number, data->transfer_mode); /* ** Get number of selections, and allocate memory to hold array */ num_selections = DXmSvnGetNumSelections(Svn); /* ** If not user defined tree, then return */ XtSetArg (arguments[0], DXmSvnNghostX, &offset_x); XtSetArg (arguments[1], DXmSvnNghostY, &offset_y); XtSetArg (arguments[2], DXmSvnNtreeStyle, &tree_style); XtGetValues (Svn, arguments, 3); if (tree_style == DXmSvnKuserDefinedTree) { /* ** Move the Entry to the new position */ DXmSvnGetSelections (Svn, selection, NULL, entry_tags, num_selections); DXmSvnSetEntryPosition (Svn, selection[0], TRUE, data->x-offset_x, data->y-offset_y); return; } } /* ** This routine is called whenever a group of entries are being dragged. */ void SvnDragging (unused_w, unused_tag, data) Widget unused_w; int unused_tag; DXmSvnCallbackStruct *data; { /* ** Announce the routine on the debugging terminal */ if (announce) printf ("Dragging handler - to x = %d, y = %d\n", data->x, data->y); } /* ** This routine is called whenever a group of entries have be drugged. */ void SvnDraggingEnd (unused_w, unused_tag, data) Widget unused_w; int unused_tag; DXmSvnCallbackStruct *data; { /* ** Announce the routine on the debugging terminal */ if (announce) printf ("DraggingEnd handler - to x = %d, y = %d\n", data->x, data->y); } /* ** This routine is called whenever a group of entries have been transfer ** either with a move or a copy function. */ void SvnEntryTransfer (unused_w, unused_tag, data) Widget unused_w; int unused_tag; DXmSvnCallbackStruct *data; { /* ** Announce the routine on the debugging terminal */ if (announce) printf ("Entry Transfer handler - to entry %d, Transfer mode = %d\n", data->entry_number, data->transfer_mode); } /* ** This routine is called whenever MB3 is pushed... */ void SvnPopupMenu(unused_w, unused_tag, data) Widget unused_w; int unused_tag; DXmSvnCallbackStruct *data; { /* ** Announce the routine on the debugging terminal */ if (announce) printf ("PopupMenu MB3 handler - on entry %d\n", data->entry_number); } /* ** This routine is called whenever the user has requested help while ** positioned within the SVN window. */ void SvnHelpRoutine (unused_w, unused_tag, data) Widget unused_w; int unused_tag; DXmSvnCallbackStruct *data; { /* ** Announce the routine on the debugging terminal */ if (announce) printf ("HelpRequested handler - Entry_number = %d, component = %d\n", data->entry_number, data->component_number); } void SvnHelpRoutine2 (unused_w, unused_tag, data) Widget unused_w; int unused_tag; DXmSvnCallbackStruct *data; { /* ** Announce the routine on the debugging terminal */ if (announce) printf ("XMNHELPCALLBACK handler - Entry_number = %d, component = %d\n", data->entry_number, data->component_number); } void MenuQuit () { /* ** Announce the routine on the debugging terminal */ if (announce) printf ("Leaving test program...\n"); /* ** Destroy the widgets (recursively) */ XtDestroyWidget (toplevel); /* ** Exit with successful VMS status code. */ exit (1); } void MenuExpandAll () { /* ** Local data declarations */ int node_number = 1; /* ** Announce the routine on the debugging terminal */ if (announce) printf ("Expand All menu pick...\n"); /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); /* ** Continue to open and traverse until all children are found */ while (node_number <= SourceNumEntries) { if (SourceIsNodeParent(node_number, 0) == TRUE) SourceOpenNode (node_number, 0); node_number++; }; /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } void MenuHighlightToggle () { /* ** Local data declarations */ XmString cs; Arg arguments[2]; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); /* ** Turn it on or off... */ if (show_highlighting == TRUE) { show_highlighting = FALSE; DXmSvnHideHighlighting (Svn); cs = XmStringCreate("Show Highlighting", XmSTRING_DEFAULT_CHARSET); } else { show_highlighting = TRUE; DXmSvnShowHighlighting (Svn); cs = XmStringCreate("Hide Highlighting", XmSTRING_DEFAULT_CHARSET); }; /* ** Change the label */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (toggleHighlightEntry, arguments, 1); XmStringFree (cs); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } void MenuToggleDisplay (unused_w, tag) Widget unused_w; int tag; { /* ** Local data declarations */ Arg arguments[2]; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); /* ** Tell SVN about the new mode */ XtSetArg (arguments[0], DXmSvnNdisplayMode, tag); XtSetValues (Svn, arguments, 1); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } void MenuToggleSelectMode (unused_w, tag) Widget unused_w; int tag; { /* ** Local data declarations */ Arg arguments[2]; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); /* ** Tell SVN about the new selection mode */ XtSetArg (arguments[0], DXmSvnNselectionMode, tag); XtSetValues (Svn, arguments, 1); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } void MenuToggleEditable() { /* ** Local data declarations */ XmString cs; Arg arguments[2]; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); /* ** Turn it on or off... */ if (Editable) { cs = XmStringCreate("Editable Text", XmSTRING_DEFAULT_CHARSET); } else { cs = XmStringCreate("Non-editable Text", XmSTRING_DEFAULT_CHARSET); }; /* ** Change the label */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (editableEntry, arguments, 1); XmStringFree (cs); /* ** Tell the source module to make the change */ SourceToggleEditable(); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } /* ** This routine is called when the user presses MB3 */ void highlight_entry (bw, event) Widget bw; XButtonEvent *event; { /* ** Local data declarations */ int Entry_number, component_number, Entry_tag; Widget w = LclFindSvnWidget(bw); /* ** Unhighlight all entries */ DXmSvnClearHighlighting (w); /* ** Map the current x and y positions to an SVN Entry number */ DXmSvnMapPosition (w, event->x, event->y, &Entry_number, &component_number, &Entry_tag); /* ** If an Entry was under the cursor, then highlight that Entry... */ if (Entry_number != 0) DXmSvnHighlightEntry (w, Entry_number); } /* ** This routine is called when the user presses SHIFT/MB3 */ void toggle_highlight (bw, event) Widget bw; XButtonEvent *event; { /* ** Local data declarations */ int Entry_number, component_number, Entry_tag; int num_highlighted; int turn_on = TRUE; Widget w = LclFindSvnWidget(bw); /* ** Map the current x and y positions to an SVN Entry number */ DXmSvnMapPosition (w, event->x, event->y, &Entry_number, &component_number, &Entry_tag); /* ** If we are not under an Entry, then leave without changing anything */ if (Entry_number == 0) return; /* ** Ask SVN how many entries are highlighted */ num_highlighted = DXmSvnGetNumHighlighted (w); /* ** If there are any highlighted, then get the list and see if this Entry is ** among those already highlighted. */ if (num_highlighted != 0) { /* ** Local data declarations */ int * highlighted_entries; int i; /* ** Allocate sufficient memory for the list */ highlighted_entries = (int *) XtCalloc (num_highlighted, sizeof(int)); /* ** Get the list from SVN */ DXmSvnGetHighlighted (w, highlighted_entries, NULL, num_highlighted); /* ** Loop looking for this Entry */ for (i = 0; i < num_highlighted; i++) if (highlighted_entries[i] == Entry_number) { turn_on = FALSE; break; }; /* ** Deallocate the memory */ XtFree (highlighted_entries); }; /* ** Now we know to either turn it off or to turn it on. */ if (turn_on == TRUE) DXmSvnHighlightEntry (w, Entry_number); else DXmSvnClearHighlight (w, Entry_number); } /* ** This routine is the callback for the centered/uncentered components button */ void MenuToggleCentered () { /* ** Local data declarations */ XmString cs; Arg arguments[2]; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); /* ** Turn it on or off... */ if (centered_components) { centered_components = FALSE; XtSetArg (arguments[0], DXmSvnNtreeCenteredComponents, centered_components); XtSetValues (Svn, arguments, 1); cs = XmStringCreate("Components Centered", XmSTRING_DEFAULT_CHARSET); } else { centered_components = TRUE; XtSetArg (arguments[0], DXmSvnNtreeCenteredComponents, centered_components); XtSetValues (Svn, arguments, 1); cs = XmStringCreate("Normal Components", XmSTRING_DEFAULT_CHARSET); }; /* ** Change the label */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (centeredEntry, arguments, 1); XmStringFree (cs); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } /* ** This routine is the callback for the centered/uncentered components button */ void MenuToggleArcs() { /* ** Local data declarations */ XmString cs; Arg arguments[2]; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); /* ** Turn it on or off... */ if (arc_width == 0) { arc_width = 15; XtSetArg (arguments[0], DXmSvnNtreeArcWidth, arc_width); XtSetValues (Svn, arguments, 1); cs = XmStringCreate("Rectangular Entries", XmSTRING_DEFAULT_CHARSET); } else { arc_width = 0; XtSetArg (arguments[0], DXmSvnNtreeArcWidth, arc_width); XtSetValues (Svn, arguments, 1); cs = XmStringCreate("Oval Entries", XmSTRING_DEFAULT_CHARSET); }; /* ** Change the label */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (arcsEntry, arguments, 1); XtFree (cs); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } /* ** This routine is the callback for the add/remove outlines button */ void MenuToggleOutlines() { /* ** Local data declarations */ XmString cs; Arg arguments[2]; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); /* ** Turn it on or off... */ if (outlines) { outlines = FALSE; XtSetArg (arguments[0], DXmSvnNtreeEntryOutlines, outlines); XtSetValues (Svn, arguments, 1); cs = XmStringCreate("Add Outlines", XmSTRING_DEFAULT_CHARSET); } else { outlines = TRUE; XtSetArg (arguments[0], DXmSvnNtreeEntryOutlines, outlines); XtSetValues (Svn, arguments, 1); cs = XmStringCreate("Remove Outlines", XmSTRING_DEFAULT_CHARSET); }; /* ** Change the label */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (outlinesEntry, arguments, 1); XtFree (cs); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } /* ** This routine is the callback for the add/remove shadows button */ void MenuToggleShadows() { /* ** Local data declarations */ XmString cs; Arg arguments[2]; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); /* ** Turn it on or off... */ if (shadows) { shadows = FALSE; XtSetArg (arguments[0], DXmSvnNtreeEntryShadows, shadows); XtSetValues (Svn, arguments, 1); cs = XmStringCreate("Add Shadows", XmSTRING_DEFAULT_CHARSET); } else { shadows = TRUE; XtSetArg (arguments[0], DXmSvnNtreeEntryShadows, shadows); XtSetValues (Svn, arguments, 1); cs = XmStringCreate("Remove Shadows", XmSTRING_DEFAULT_CHARSET); }; /* ** Change the label */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (shadowsEntry, arguments, 1); XtFree (cs); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } /* ** This routine is the callback for the Perpendicular/diagonal lines button */ void MenuToggleLineStyle () { /* ** Local data declarations */ XmString cs; Arg arguments[2]; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); /* ** Turn it on or off... */ if (perpendicular_lines) { perpendicular_lines = FALSE; XtSetArg (arguments[0], DXmSvnNtreePerpendicularLines, perpendicular_lines); XtSetValues (Svn, arguments, 1); cs = XmStringCreate("Perpendicular Lines", XmSTRING_DEFAULT_CHARSET); } else { perpendicular_lines = TRUE; XtSetArg (arguments[0], DXmSvnNtreePerpendicularLines, perpendicular_lines); XtSetValues (Svn, arguments, 1); cs = XmStringCreate("Diagonal Lines", XmSTRING_DEFAULT_CHARSET); }; /* ** Change the label */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (lineStyleEntry, arguments, 1); XtFree (cs); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } /* ** This routine is the callback for the Top tree style button */ void MenuTopTreeStyle () { /* ** Local data declarations */ Arg arguments[5]; XmString cs; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); cs = XmStringCreate("Top Tree Navigation", XmSTRING_DEFAULT_CHARSET); XtSetArg (arguments[0], DXmSvnNnavWindowTitle, cs); XtSetArg (arguments[1], DXmSvnNtreeStyle, DXmSvnKtopTree); XtSetValues (Svn, arguments, 2); XtFree (cs); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } /* ** This routine is the callback for the Left tree style button */ void MenuLeftTreeStyle () { /* ** Local data declarations */ Arg arguments[5]; XmString cs; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); cs = XmStringCreate("Left Tree Navigation", XmSTRING_DEFAULT_CHARSET); XtSetArg (arguments[0], DXmSvnNnavWindowTitle, cs); XtSetArg (arguments[1], DXmSvnNtreeStyle, DXmSvnKhorizontalTree); XtSetValues (Svn, arguments, 2); XtFree (cs); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } /* ** This routine is the callback for the Outline tree style button */ void MenuOutlineTreeStyle () { /* ** Local data declarations */ Arg arguments[5]; XmString cs; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); cs = XmStringCreate("Outline Tree Navigation", XmSTRING_DEFAULT_CHARSET); XtSetArg (arguments[0], DXmSvnNnavWindowTitle, cs); XtSetArg (arguments[1], DXmSvnNtreeStyle, DXmSvnKoutlineTree); XtSetValues (Svn, arguments, 2); XtFree (cs); /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } /* ** This routine is the callback for the UserDefine tree style button */ void MenuUserDefTreeStyle () { /* ** Local data declarations */ Arg arguments[5]; XmString cs; int i; int x, y; /* ** Disable the widget. This would not be necessary if this routine was ** being called in response to an SVN callback. */ DXmSvnDisableDisplay (Svn); cs = XmStringCreate("User Defined Navigation", XmSTRING_DEFAULT_CHARSET); XtSetArg (arguments[0], DXmSvnNnavWindowTitle, cs); XtSetArg (arguments[1], DXmSvnNtreeStyle, DXmSvnKuserDefinedTree); XtSetValues (Svn, arguments, 2); XtFree (cs); /* ** Loop through entries setting their default position */ x = 30; y = 100; for (i = 1; i <= SourceNumEntries; i++) { DXmSvnSetEntryPosition (Svn, i, FALSE, x, y); x += 30; y += 30; }; /* ** Re-enable the SVN Widget. */ DXmSvnEnableDisplay (Svn); } /* ** This routine is the callback for the Select All button */ void MenuSelectAll() { DXmSvnValidateAll(Svn); DXmSvnSelectAll(Svn); } /* ** This routine is the callback for the Highlight All button */ void MenuHighlightAll() { DXmSvnHighlightAll(Svn); } /* ** This routine is the callback for the Show/Hide selections entry */ void MenuToggleSelections() { /* ** Local data declarations */ XmString cs; Arg arguments[2]; /* ** Toggle the state of showing selected items */ if (!show_selections) { DXmSvnShowSelections(Svn); show_selections = TRUE; cs = XmStringCreate("Hide Selections", XmSTRING_DEFAULT_CHARSET); } else { DXmSvnHideSelections(Svn); show_selections = FALSE; cs = XmStringCreate("Show Selections", XmSTRING_DEFAULT_CHARSET); } /* ** Change the label on the button */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (toggleSelectionsEntry, arguments, 1); XmStringFree(cs); } /* ** This routine is the callback for the Show/Hide selections entry */ void MenuToggleFixed() { /* ** Local data declarations */ XmString cs; Arg arguments[2]; /* ** Toggle the state of showing selected items */ if (!fixed_width_entries) { fixed_width_entries = TRUE; cs = XmStringCreate("Variables Width Entries", XmSTRING_DEFAULT_CHARSET); } else { fixed_width_entries = FALSE; cs = XmStringCreate("Fixed Width Entries", XmSTRING_DEFAULT_CHARSET); } /* ** Change the resource */ XtSetArg (arguments[0], DXmSvnNfixedWidthEntries, fixed_width_entries); XtSetValues (Svn, arguments, 1); /* ** Change the label on the button */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (toggleFixedEntry, arguments, 1); XmStringFree(cs); } /* ** This routine is the callback for the Show/Hide selections entry */ void MenuToggleTruncate() { /* ** Local data declarations */ XmString cs; Arg arguments[2]; /* ** Toggle the state of showing selected items */ if (truncate_text) { truncate_text = FALSE; cs = XmStringCreate("Truncate Text", XmSTRING_DEFAULT_CHARSET); } else { truncate_text = TRUE; cs = XmStringCreate("Overflow Text", XmSTRING_DEFAULT_CHARSET); } /* ** Change the resource */ XtSetArg (arguments[0], DXmSvnNtruncateText, truncate_text); XtSetValues (Svn, arguments, 1); /* ** Change the label on the button */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (toggleTruncateEntry, arguments, 1); XmStringFree(cs); } /* ** This routine is the callback for the insert/remove component 3 */ void MenuToggleShowing3() { /* ** Local data declarations */ XmString cs,cs2; Arg arguments[2]; /* ** Disable the widget */ DXmSvnDisableDisplay (Svn); /* ** Toggle the state of showing selected items */ if (showing_3) { showing_3 = FALSE; cs = XmStringCreate("Insert Component 3", XmSTRING_DEFAULT_CHARSET); DXmSvnRemoveComponent (Svn, 3); SourceNumComps--; } else { showing_3 = TRUE; cs = XmStringCreate("Remove Component 3", XmSTRING_DEFAULT_CHARSET); cs2 = XmStringCreate ("Component Three", XmSTRING_DEFAULT_CHARSET); DXmSvnInsertComponent (Svn, 3, 0, cs2); SourceNumComps++; } /* ** Enable the widget */ DXmSvnEnableDisplay (Svn); /* ** Change the label on the button */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (toggleShowing3, arguments, 1); XmStringFree(cs); } /* ** This routine is the callback for the insert/remove component 4 */ void MenuToggleShowing4() { /* ** Local data declarations */ XmString cs,cs2; Arg arguments[2]; int comp_number; /* ** If we are not showing 3, then this is 3... */ comp_number = 3; if (showing_3) comp_number++; /* ** Disable the widget */ DXmSvnDisableDisplay (Svn); /* ** Toggle the state of showing selected items */ if (showing_4) { showing_4 = FALSE; cs = XmStringCreate("Insert Component 4", XmSTRING_DEFAULT_CHARSET); DXmSvnRemoveComponent (Svn, comp_number); SourceNumComps--; } else { showing_4 = TRUE; cs = XmStringCreate("Remove Component 4", XmSTRING_DEFAULT_CHARSET); cs2 = XmStringCreate ("Component Four", XmSTRING_DEFAULT_CHARSET); DXmSvnInsertComponent (Svn, comp_number, 0, cs2); SourceNumComps++; } /* ** Enable the widget */ DXmSvnEnableDisplay (Svn); /* ** Change the label on the button */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (toggleShowing4, arguments, 1); XmStringFree(cs); } /* ** This routine is the callback for the insert/remove component 5 */ void MenuToggleShowing5() { /* ** Local data declarations */ XmString cs,cs2; Arg arguments[2]; int comp_number; /* ** If we are not showing 3, then this is 3... */ comp_number = 3; if (showing_3) comp_number++; if (showing_4) comp_number++; /* ** Disable the widget */ DXmSvnDisableDisplay (Svn); /* ** Toggle the state of showing selected items */ if (showing_5) { showing_5 = FALSE; cs = XmStringCreate("Insert Component 5", XmSTRING_DEFAULT_CHARSET); DXmSvnRemoveComponent (Svn, comp_number); SourceNumComps--; } else { showing_5 = TRUE; cs = XmStringCreate("Remove Component 5", XmSTRING_DEFAULT_CHARSET); cs2 = XmStringCreate ("Component Five", XmSTRING_DEFAULT_CHARSET); DXmSvnInsertComponent (Svn, comp_number, 0, cs2); SourceNumComps++; } /* ** Enable the widget */ DXmSvnEnableDisplay (Svn); /* ** Change the label on the button */ XtSetArg (arguments[0], XmNlabelString, cs); XtSetValues (toggleShowing5, arguments, 1); XmStringFree(cs); } /* ** This routine is the callback for the Clear Selections button */ void MenuClearSelections() { DXmSvnClearSelections(Svn); } /* ** This routine is the callback for the Clear Highlighting button */ void MenuClearHighlight() { DXmSvnClearHighlighting(Svn); } /* ** This routine sets all the position options insensitive if anything but one ** entry is selected. It is a callback on the pulldown entry */ void SetPositionMenuSens () { /* ** Local variables */ int Sensitive = (DXmSvnGetNumSelections(Svn) == 1); XtSetSensitive (positionTopEntry,Sensitive); XtSetSensitive (positionMiddleEntry,Sensitive); XtSetSensitive (positionBottomEntry,Sensitive); } /* ** This routine is the callback routine to postion the selected entry at a ** desired position in the display. The postion is determined by the tag to ** the callback routine. We are guaranteed that only a single entry is ** selected because the otherwise the postioning buttons in the menu are ** greyed. */ void MenuPosition (unused_w, tag) Widget unused_w; int tag; { /* ** Local variables */ int selections [1]; /* ** Only can position one entry at a time, so just get it */ DXmSvnDisableDisplay(Svn); if ((tag != DXmSvnKpositionNextPage) && (tag != DXmSvnKpositionPreviousPage)) DXmSvnGetSelections (Svn, selections, NULL, NULL, 1); DXmSvnPositionDisplay(Svn, selections[0], tag); DXmSvnEnableDisplay(Svn); } /* ** This routine is the callback routine to set the sensitivity of the selected ** entries. The callback tag determines if the entries are made Sensitive or ** insensitive. */ void MenuSetSensitivity(unused_w, tag) Widget unused_w; int tag; { /* ** Local variables */ int selections[1]; int i; /* ** Disable Svn while making changes */ DXmSvnDisableDisplay(Svn); /* ** If we are making something insensitive loop through the selections one at a ** time and make insensitive. Otherwise loop through all entries making ** them sensitive. We have added an option to insensitize the entire widget. */ if (tag == 0) while (DXmSvnGetNumSelections(Svn) > 0) { DXmSvnGetSelections (Svn, selections, NULL, NULL, 1); DXmSvnSetEntrySensitivity(Svn, selections[0], FALSE); DXmSvnClearSelection(Svn, selections[0]); } if (tag == 1) for (i = 1; i <= SourceNumEntries; i++) DXmSvnSetEntrySensitivity(Svn, i, TRUE); if (tag == 2) XtSetSensitive(Svn, FALSE); if (tag == 3) XtSetSensitive(Svn, TRUE); /* ** Changes done so reenable */ DXmSvnEnableDisplay(Svn); } /* ** This routine is the callback routine to destroy and recreate ** the current SVN widget. */ void MenuRecreate (unused_w) Widget unused_w; { /* ** Close all of the nodes first. */ DXmSvnDisableDisplay(Svn); SourceCloseNode (1, 0); DXmSvnEnableDisplay(Svn); /* ** When the widget is recreated it will be non-editable by default. */ if (Editable) MenuToggleEditable(); /* ** Remove references to children of Svn to be destroyed from global ** data structure. */ LclResetNodes(); /* ** Destroy the SVN widget */ XtDestroyWidget (Svn); /* ** Create the widget */ LclCreateSvn (); } /* ** Local procedure that creates the SVN widget and sets state information */ void LclCreateSvn () { /* ** Local data declarations */ Arg arguments[20]; XmString cs; /* ** Create the SVN widget */ XtSetArg (arguments[0], XmNwidth, 300 ); XtSetArg (arguments[1], XmNheight, 400 ); XtSetArg (arguments[2], DXmSvnNselectAndConfirmCallback, SvnConfirmedCB ); /* XtSetArg (arguments[3], XmNhelpCallback, SvnHelpRoutineCB2); */ XtSetArg (arguments[3], DXmSvnNhelpRequestedCallback, SvnHelpRoutineCB ); XtSetArg (arguments[4], DXmSvnNattachToSourceCallback, SvnAttachCB ); XtSetArg (arguments[5], DXmSvnNdetachFromSourceCallback, SvnDetachCB ); XtSetArg (arguments[6], DXmSvnNgetEntryCallback, SvnGetEntryCB ); XtSetArg (arguments[7], DXmSvnNextendConfirmCallback, SvnExtendedCB ); XtSetArg (arguments[8], DXmSvnNentrySelectedCallback, SvnSelectedCB ); XtSetArg (arguments[9], DXmSvnNentryUnselectedCallback, SvnUnselectedCB ); XtSetArg (arguments[10], DXmSvnNselectionsDraggedCallback, SvnDraggedCB ); XtSetArg (arguments[11], DXmSvnNexpectHighlighting, TRUE ); XtSetArg (arguments[12], DXmSvnNtransitionsDoneCallback, SvnTransitionsDoneCB); XtSetArg (arguments[13], DXmSvnNdisplayChangedCallback, SvnDisplayChangedCB ); XtSetArg (arguments[14], DXmSvnNentryTransferCallback, SvnEntryTransferCB ); XtSetArg (arguments[15], DXmSvnNpopupMenuCallback, SvnPopupMenuCB ); XtSetArg (arguments[16], DXmSvnNstartLocationCursor, 4); XtSetArg (arguments[17], DXmSvnNdisplayMode, display_mode); /* ** Create the nav window title compound string */ cs = XmStringCreate("Default Tree Title", XmSTRING_DEFAULT_CHARSET); XtSetArg (arguments[18], DXmSvnNnavWindowTitle, cs); /* XtSetArg (arguments[18], DXmNlayoutDirection, DXmLAYOUT_LEFT_DOWN);*/ XtSetArg (arguments[19], DXmSvnNshowPathToRoot, FALSE); /* ** Create the SVN widget */ Svn = (Widget) DXmCreateSvn (mainwindow, "Svn", arguments, 20); fontlist = XmFontListCreate (XLoadQueryFont (XtDisplay (Svn), "-*-Menu-Medium-R-Normal--*-120-*-*-P-*-ISO8859-1"), XmSTRING_DEFAULT_CHARSET); /* ** Free the compound string */ XtFree (cs); /* ** Issue a set values to test a bug. */ XtSetArg (arguments[0], DXmSvnNstartColumnComponent, 3 ); XtSetArg (arguments[1], DXmSvnNcolumnLines, TRUE); XtSetValues (Svn, arguments, 2); XtManageChild (Svn); /* ** Determine the state of some resources */ XtSetArg (arguments[0], DXmSvnNdisplayMode, &display_mode); XtSetArg (arguments[1], DXmSvnNtreePerpendicularLines, &perpendicular_lines); XtSetArg (arguments[2], DXmSvnNtreeCenteredComponents, ¢ered_components); XtSetArg (arguments[3], DXmSvnNtreeArcWidth, &arc_width); XtSetArg (arguments[4], DXmSvnNtreeEntryShadows, &shadows); XtSetArg (arguments[5], DXmSvnNtreeEntryOutlines, &outlines); XtSetArg (arguments[6], DXmSvnNfixedWidthEntries, &fixed_width_entries); XtSetArg (arguments[7], DXmSvnNtruncateText, &truncate_text); XtGetValues (Svn, arguments, 8); } Widget LclFindSvnWidget (w) Widget w; { /* ** Local data declarations */ WidgetClass w_class; /* ** Get the class record of the widget */ w_class = XtClass(w); /* ** If this is an SVN widget, then return it. */ /* if (w_class == (WidgetClass) dxmSvnWidgetClass) return w; */ /* ** Get the superclass of this class and see if that is an SVN widget */ w_class = w_class->core_class.superclass; /* if (w_class == (WidgetClass) dxmSvnWidgetClass) return w; */ /* ** Otherwise call ourself looking at the parent of this widget. */ return (LclFindSvnWidget (XtParent(w))); }