Context Navigation

source: cprs/trunk/CPRS-Chart/Templates/fTemplateEditor.pas@ 1094

Last change on this file since 1094 was 829, checked in by Kevin Toppenberg, 14 years ago
Upgrade to version 27
File size: 126.6 KB

Rev	Line
[456]	1	unit fTemplateEditor;
	2	{The OwnerScan conditional compile varaible was created because there were too
	3	many things that needed to be done to incorporate the viewing of other user's
	4	personal templates by clinical coordinators. These include:
	5	Changing the Personal tree.
	6	expanding entirely new personal list when personal list changes
	7	when click on stop editing shared button, and personal is for someone else,
	8	need to resync to personal list.
	9
	10	HOT HEYS NOT YET ASSIGNED:
	11	JFKQRUVZ
	12	}
	13	{$DEFINE OwnerScan}
	14	{$UNDEF OwnerScan}
	15	interface
	16
	17	uses
	18	Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
	19	ExtCtrls, StdCtrls, ComCtrls, ORCtrls, Buttons, Mask, ORFn, ORNet,
[829]	20	uTemplates, Menus, ImgList, Clipbrd, ToolWin, MenuBar, TypInfo, MSXML_TLB, fBase508Form,
	21	VA508AccessibilityManager, VA508ImageListLabeler;
[456]	22
	23	type
	24	TTemplateTreeControl = (tcDel, tcUp, tcDown, tcLbl, tcCopy);
	25	TTemplateTreeType = (ttShared, ttPersonal);
	26
[829]	27	TfrmTemplateEditor = class(TfrmBase508Form)
[456]	28	splMain: TSplitter;
[829]	29	pnlBottom: TPanel;
[456]	30	btnApply: TButton;
	31	btnCancel: TButton;
	32	btnOK: TButton;
	33	pnlBoilerplate: TPanel;
	34	reBoil: TRichEdit;
	35	pnlTop: TPanel;
	36	pnlRightTop: TPanel;
	37	splProperties: TSplitter;
	38	pnlCopyBtns: TPanel;
	39	sbCopyLeft: TBitBtn;
	40	sbCopyRight: TBitBtn;
	41	lblCopy: TLabel;
	42	splMiddle: TSplitter;
	43	pnlShared: TPanel;
	44	lblShared: TLabel;
	45	tvShared: TORTreeView;
	46	pnlSharedBottom: TPanel;
	47	sbShUp: TBitBtn;
	48	sbShDown: TBitBtn;
	49	sbShDelete: TBitBtn;
	50	cbShHide: TCheckBox;
	51	pnlSharedGap: TPanel;
	52	pnlPersonal: TPanel;
	53	lblPersonal: TLabel;
	54	tvPersonal: TORTreeView;
	55	pnlPersonalBottom: TPanel;
	56	sbPerUp: TBitBtn;
	57	sbPerDown: TBitBtn;
	58	sbPerDelete: TBitBtn;
	59	cbPerHide: TCheckBox;
	60	pnlPersonalGap: TPanel;
	61	popTemplates: TPopupMenu;
	62	mnuCollapseTree: TMenuItem;
	63	mnuFindTemplates: TMenuItem;
	64	popBoilerplate: TPopupMenu;
	65	mnuBPInsertObject: TMenuItem;
	66	mnuBPErrorCheck: TMenuItem;
	67	mnuBPSpellCheck: TMenuItem;
	68	pnlGroupBP: TPanel;
	69	reGroupBP: TRichEdit;
	70	lblGroupBP: TLabel;
	71	splBoil: TSplitter;
	72	pnlGroupBPGap: TPanel;
	73	tmrAutoScroll: TTimer;
	74	popGroup: TPopupMenu;
	75	mnuGroupBPCopy: TMenuItem;
	76	mnuBPCut: TMenuItem;
	77	N2: TMenuItem;
	78	mnuBPCopy: TMenuItem;
	79	mnuBPPaste: TMenuItem;
	80	N4: TMenuItem;
	81	mnuGroupBPSelectAll: TMenuItem;
	82	mnuBPSelectAll: TMenuItem;
	83	N6: TMenuItem;
	84	mnuNodeCopy: TMenuItem;
	85	mnuNodePaste: TMenuItem;
	86	mnuNodeDelete: TMenuItem;
	87	N8: TMenuItem;
	88	mnuBPUndo: TMenuItem;
	89	cbEditShared: TCheckBox;
	90	pnlProperties: TPanel;
	91	gbProperties: TGroupBox;
	92	lblName: TLabel;
	93	lblLines: TLabel;
	94	cbExclude: TORCheckBox;
	95	cbActive: TCheckBox;
	96	edtGap: TCaptionEdit;
	97	udGap: TUpDown;
	98	edtName: TCaptionEdit;
	99	mnuMain: TMainMenu;
	100	mnuEdit: TMenuItem;
	101	mnuUndo: TMenuItem;
	102	N9: TMenuItem;
	103	mnuCut: TMenuItem;
	104	mnuCopy: TMenuItem;
	105	mnuPaste: TMenuItem;
	106	mnuSelectAll: TMenuItem;
	107	N11: TMenuItem;
	108	mnuInsertObject: TMenuItem;
	109	mnuErrorCheck: TMenuItem;
	110	mnuSpellCheck: TMenuItem;
	111	N13: TMenuItem;
	112	mnuGroupBoilerplate: TMenuItem;
	113	mnuGroupCopy: TMenuItem;
	114	mnuGroupSelectAll: TMenuItem;
	115	mnuTemplate: TMenuItem;
	116	mnuTCopy: TMenuItem;
	117	mnuTPaste: TMenuItem;
	118	mnuTDelete: TMenuItem;
	119	N12: TMenuItem;
	120	pnlShSearch: TPanel;
	121	btnShFind: TORAlignButton;
	122	edtShSearch: TCaptionEdit;
	123	cbShMatchCase: TCheckBox;
	124	cbShWholeWords: TCheckBox;
	125	pnlPerSearch: TPanel;
	126	btnPerFind: TORAlignButton;
	127	edtPerSearch: TCaptionEdit;
	128	cbPerMatchCase: TCheckBox;
	129	cbPerWholeWords: TCheckBox;
	130	mnuFindShared: TMenuItem;
	131	mnuFindPersonal: TMenuItem;
	132	N3: TMenuItem;
	133	mnuShCollapse: TMenuItem;
	134	mnuPerCollapse: TMenuItem;
	135	pnlMenuBar: TPanel;
	136	lblPerOwner: TLabel;
	137	cboOwner: TORComboBox;
	138	btnNew: TORAlignButton;
	139	pnlMenu: TPanel;
	140	mbMain: TMenuBar;
	141	mnuNewTemplate: TMenuItem;
	142	Bevel1: TBevel;
	143	mnuNodeNew: TMenuItem;
	144	mnuBPCheckGrammar: TMenuItem;
	145	mnuCheckGrammar: TMenuItem;
	146	N1: TMenuItem;
	147	N7: TMenuItem;
	148	N14: TMenuItem;
	149	mnuSort: TMenuItem;
	150	N15: TMenuItem;
	151	mnuNodeSort: TMenuItem;
	152	mnuTry: TMenuItem;
	153	mnuBPTry: TMenuItem;
	154	mnuAutoGen: TMenuItem;
	155	mnuNodeAutoGen: TMenuItem;
	156	pnlNotes: TPanel;
	157	reNotes: TRichEdit;
	158	splNotes: TSplitter;
	159	lblNotes: TLabel;
	160	popNotes: TPopupMenu;
	161	mnuNotesUndo: TMenuItem;
	162	MenuItem2: TMenuItem;
	163	mnuNotesCut: TMenuItem;
	164	mnuNotesCopy: TMenuItem;
	165	mnuNotesPaste: TMenuItem;
	166	MenuItem6: TMenuItem;
	167	mnuNotesSelectAll: TMenuItem;
	168	MenuItem8: TMenuItem;
	169	mnuNotesGrammar: TMenuItem;
	170	mnuNotesSpelling: TMenuItem;
	171	cbNotes: TCheckBox;
	172	gbDialogProps: TGroupBox;
	173	cbDisplayOnly: TCheckBox;
	174	cbOneItemOnly: TCheckBox;
	175	cbHideItems: TORCheckBox;
	176	cbFirstLine: TCheckBox;
	177	cbHideDlgItems: TCheckBox;
	178	cbIndent: TCheckBox;
	179	mnuTools: TMenuItem;
	180	mnuEditTemplateFields: TMenuItem;
	181	N16: TMenuItem;
	182	mnuImportTemplate: TMenuItem;
	183	mnuExportTemplate: TMenuItem;
	184	mnuBPInsertField: TMenuItem;
	185	mnuInsertField: TMenuItem;
	186	cbEditUser: TCheckBox;
	187	dlgImport: TOpenDialog;
	188	dlgExport: TSaveDialog;
	189	cbxType: TCaptionComboBox;
	190	lblType: TLabel;
	191	cbxRemDlgs: TORComboBox;
	192	lblRemDlg: TLabel;
	193	N17: TMenuItem;
	194	mnuTemplateIconLegend: TMenuItem;
	195	pnlBP: TPanel;
	196	lblBoilerplate: TLabel;
	197	cbLongLines: TCheckBox;
	198	cbLock: TORCheckBox;
	199	mnuRefresh: TMenuItem;
	200	lblBoilRow: TLabel;
	201	lblGroupRow: TLabel;
	202	lblBoilCol: TLabel;
	203	lblGroupCol: TLabel;
	204	pnlCOM: TPanel;
	205	lblCOMParam: TLabel;
	206	edtCOMParam: TCaptionEdit;
	207	cbxCOMObj: TORComboBox;
	208	lblCOMObj: TLabel;
	209	pnlLink: TPanel;
	210	cbxLink: TORComboBox;
	211	lblLink: TLabel;
[829]	212	imgLblTemplates: TVA508ImageListLabeler;
[456]	213	procedure btnNewClick(Sender: TObject);
	214	procedure btnApplyClick(Sender: TObject);
	215	procedure FormCreate(Sender: TObject);
	216	procedure cboOwnerNeedData(Sender: TObject; const StartFrom: String;
	217	Direction, InsertAt: Integer);
	218	procedure cboOwnerChange(Sender: TObject);
	219	procedure tvPersonalExpanding(Sender: TObject; Node: TTreeNode;
	220	var AllowExpansion: Boolean);
	221	procedure tvSharedExpanding(Sender: TObject; Node: TTreeNode;
	222	var AllowExpansion: Boolean);
	223	procedure tvTreeGetImageIndex(Sender: TObject; Node: TTreeNode);
	224	procedure tvTreeGetSelectedIndex(Sender: TObject; Node: TTreeNode);
	225	procedure tvTreeChange(Sender: TObject; Node: TTreeNode);
	226	procedure splMainMoved(Sender: TObject);
	227	procedure pnlBoilerplateResize(Sender: TObject);
	228	procedure edtNameOldChange(Sender: TObject);
	229	procedure cbActiveClick(Sender: TObject);
	230	procedure cbExcludeClick(Sender: TObject);
	231	procedure edtGapChange(Sender: TObject);
	232	procedure tvTreeEnter(Sender: TObject);
	233	procedure tvTreeNodeEdited(Sender: TObject; Node: TTreeNode;
	234	var S: String);
	235	procedure cbShHideClick(Sender: TObject);
	236	procedure cbPerHideClick(Sender: TObject);
	237	procedure FormDestroy(Sender: TObject);
	238	procedure sbMoveUpClick(Sender: TObject);
	239	procedure sbMoveDownClick(Sender: TObject);
	240	procedure sbDeleteClick(Sender: TObject);
	241	procedure tvTreeDragging(Sender: TObject; Node: TTreeNode;
	242	var CanDrag: Boolean);
	243	procedure tvTreeDragOver(Sender, Source: TObject; X, Y: Integer;
	244	State: TDragState; var Accept: Boolean);
	245	procedure tvTreeDragDrop(Sender, Source: TObject; X, Y: Integer);
	246	procedure sbCopyLeftClick(Sender: TObject);
	247	procedure sbCopyRightClick(Sender: TObject);
	248	procedure reBoilChange(Sender: TObject);
	249	procedure cbEditSharedClick(Sender: TObject);
	250	procedure popTemplatesPopup(Sender: TObject);
	251	procedure mnuCollapseTreeClick(Sender: TObject);
	252	procedure mnuFindTemplatesClick(Sender: TObject);
	253	procedure btnFindClick(Sender: TObject);
	254	procedure edtSearchChange(Sender: TObject);
	255	procedure edtShSearchEnter(Sender: TObject);
	256	procedure edtShSearchExit(Sender: TObject);
	257	procedure edtPerSearchEnter(Sender: TObject);
	258	procedure edtPerSearchExit(Sender: TObject);
	259	procedure btnOKClick(Sender: TObject);
	260	procedure FormShow(Sender: TObject);
	261	procedure mnuBPInsertObjectClick(Sender: TObject);
	262	procedure mnuBPErrorCheckClick(Sender: TObject);
	263	procedure popBoilerplatePopup(Sender: TObject);
	264	procedure btnCancelClick(Sender: TObject);
	265	procedure FormCloseQuery(Sender: TObject; var CanClose: Boolean);
	266	procedure mnuBPSpellCheckClick(Sender: TObject);
	267	procedure splBoilMoved(Sender: TObject);
	268	procedure edtGapKeyPress(Sender: TObject; var Key: Char);
	269	procedure edtNameExit(Sender: TObject);
	270	procedure tmrAutoScrollTimer(Sender: TObject);
	271	procedure tvTreeStartDrag(Sender: TObject;
	272	var DragObject: TDragObject);
	273	procedure tvTreeEndDrag(Sender, Target: TObject; X, Y: Integer);
	274	procedure mnuGroupBPCopyClick(Sender: TObject);
	275	procedure popGroupPopup(Sender: TObject);
	276	procedure mnuBPCutClick(Sender: TObject);
	277	procedure mnuBPCopyClick(Sender: TObject);
	278	procedure mnuBPPasteClick(Sender: TObject);
	279	procedure mnuGroupBPSelectAllClick(Sender: TObject);
	280	procedure mnuBPSelectAllClick(Sender: TObject);
	281	procedure mnuNodeDeleteClick(Sender: TObject);
	282	procedure mnuNodeCopyClick(Sender: TObject);
	283	procedure mnuNodePasteClick(Sender: TObject);
	284	procedure mnuBPUndoClick(Sender: TObject);
	285	procedure tvTreeKeyDown(Sender: TObject; var Key: Word;
	286	Shift: TShiftState);
	287	procedure mnuEditClick(Sender: TObject);
	288	procedure mnuGroupBoilerplateClick(Sender: TObject);
	289	procedure cbShFindOptionClick(Sender: TObject);
	290	procedure cbPerFindOptionClick(Sender: TObject);
	291	procedure mnuTemplateClick(Sender: TObject);
	292	procedure mnuFindSharedClick(Sender: TObject);
	293	procedure mnuFindPersonalClick(Sender: TObject);
	294	procedure mnuShCollapseClick(Sender: TObject);
	295	procedure mnuPerCollapseClick(Sender: TObject);
	296	procedure pnlShSearchResize(Sender: TObject);
	297	procedure pnlPerSearchResize(Sender: TObject);
	298	procedure pnlPropertiesResize(Sender: TObject);
	299	procedure mbMainResize(Sender: TObject);
	300	procedure mnuBPCheckGrammarClick(Sender: TObject);
	301	procedure mnuSortClick(Sender: TObject);
	302	procedure pnlBoilerplateCanResize(Sender: TObject; var NewWidth,
	303	NewHeight: Integer; var Resize: Boolean);
	304	procedure mnuBPTryClick(Sender: TObject);
	305	procedure mnuAutoGenClick(Sender: TObject);
	306	procedure reNotesChange(Sender: TObject);
	307	procedure mnuNotesUndoClick(Sender: TObject);
	308	procedure mnuNotesCutClick(Sender: TObject);
	309	procedure mnuNotesCopyClick(Sender: TObject);
	310	procedure mnuNotesPasteClick(Sender: TObject);
	311	procedure mnuNotesSelectAllClick(Sender: TObject);
	312	procedure mnuNotesGrammarClick(Sender: TObject);
	313	procedure mnuNotesSpellingClick(Sender: TObject);
	314	procedure popNotesPopup(Sender: TObject);
	315	procedure cbNotesClick(Sender: TObject);
	316	procedure cbDisplayOnlyClick(Sender: TObject);
	317	procedure cbFirstLineClick(Sender: TObject);
	318	procedure cbOneItemOnlyClick(Sender: TObject);
	319	procedure cbHideDlgItemsClick(Sender: TObject);
	320	procedure cbHideItemsClick(Sender: TObject);
	321	procedure cbIndentClick(Sender: TObject);
	322	procedure mnuToolsClick(Sender: TObject);
	323	procedure mnuEditTemplateFieldsClick(Sender: TObject);
	324	procedure mnuBPInsertFieldClick(Sender: TObject);
	325	procedure mnuExportTemplateClick(Sender: TObject);
	326	procedure mnuImportTemplateClick(Sender: TObject);
	327	procedure cbxTypeDrawItem(Control: TWinControl; Index: Integer;
	328	Rect: TRect; State: TOwnerDrawState);
	329	procedure cbxTypeChange(Sender: TObject);
	330	procedure cbxRemDlgsChange(Sender: TObject);
	331	procedure mnuTemplateIconLegendClick(Sender: TObject);
	332	procedure cbLongLinesClick(Sender: TObject);
	333	procedure cbLockClick(Sender: TObject);
	334	procedure mnuRefreshClick(Sender: TObject);
	335	procedure reResizeRequest(Sender: TObject; Rect: TRect);
	336	procedure reBoilSelectionChange(Sender: TObject);
	337	procedure reGroupBPSelectionChange(Sender: TObject);
	338	procedure cbxCOMObjChange(Sender: TObject);
	339	procedure edtCOMParamChange(Sender: TObject);
	340	procedure cbxLinkNeedData(Sender: TObject; const StartFrom: String;
	341	Direction, InsertAt: Integer);
	342	procedure cbxLinkChange(Sender: TObject);
	343	procedure reBoilKeyUp(Sender: TObject; var Key: Word;
	344	Shift: TShiftState);
	345	procedure reBoilKeyPress(Sender: TObject; var Key: Char);
	346	procedure reBoilKeyDown(Sender: TObject; var Key: Word;
	347	Shift: TShiftState);
[829]	348	procedure FormClose(Sender: TObject; var Action: TCloseAction);
[456]	349	private
	350	FLastRect: TRect;
	351	FForceContainer: boolean;
	352	FSavePause: integer;
	353	FCopyNode: TTreeNode;
	354	FPasteNode: TTreeNode;
	355	FCopying: boolean;
	356	FDropNode: TTreeNode;
	357	FDropInto: boolean;
	358	FDragNode: TTreeNode;
	359	FPersonalEmptyNodeCount: integer;
	360	FSharedEmptyNodeCount: integer;
	361	// FOldPersonalTemplate: TTemplate;
	362	FCurrentPersonalUser: Int64;
	363	FCanEditPersonal: boolean;
	364	FCanEditShared: boolean;
	365	FUpdating: boolean;
	366	FCurTree: TTreeView;
	367	FTreeControl: array[TTemplateTreeType, TTemplateTreeControl] of TControl;
	368	FInternalHiddenExpand :boolean;
	369	FFindShOn: boolean;
	370	FFindShNext: boolean;
	371	FLastFoundShNode: TTreeNode;
	372	FFindPerOn: boolean;
	373	FFindPerNext: boolean;
	374	FLastFoundPerNode: TTreeNode;
	375	FFirstShow: boolean;
	376	FFocusName: boolean;
	377	FOK2Close: boolean;
	378	FBtnNewNode: TTreeNode;
	379	FLastDropNode: TTreeNode;
	380	FFromMainMenu: boolean;
	381	FMainMenuTree: TTreeView;
	382	FDragOverCount: integer;
	383	FBPOK: boolean;
	384	FImportingFromXML: boolean;
	385	FXMLTemplateElement: IXMLDOMNode;
	386	FXMLFieldElement: IXMLDOMNode;
	387	FCanDoReminders: boolean;
	388	FCanDoCOMObjects: boolean;
[829]	389	//FPersonalObjects: TStringList;
[456]	390	FShowingTemplate: TTemplate;
	391	FConsultServices: TStringList;
	392	FNavigatingTab: boolean;
	393	protected
	394	procedure UpdateXY(re: TRichEdit; lblX, lblY: TLabel);
	395	function IsTemplateLocked(Node: TTreeNode): boolean;
	396	procedure RefreshData;
	397	procedure ShowTemplateType(Template: TTemplate);
	398	procedure DisplayBoilerplate(Node: TTreeNode);
	399	procedure NewPersonalUser(UsrIEN: Int64);
	400	procedure HideControls;
	401	procedure EnableControls(ok, Root: boolean);
	402	procedure EnableNavControls;
	403	procedure MoveCopyButtons;
	404	procedure ShowInfo(Node: TTreeNode);
	405	function ChangeTree(NewTree: TTreeView): boolean;
	406	procedure Resync(const Templates: array of TTemplate);
	407	function AllowMove(ADropNode, ADragNode: TTreeNode): boolean;
	408	function CanClone(const Node: TTreeNode): boolean;
	409	function Clone(Node: TTreeNode): boolean;
	410	procedure SharedEditing;
	411	function GetTree: TTreeView;
	412	procedure SetFindNext(const Tree: TTreeView; const Value: boolean);
	413	function ScanNames: boolean;
	414	function PasteOK: boolean;
	415	function AutoDel(Template: TTemplate): boolean;
	416	procedure cbClick(Sender: TCheckBox; Index: integer);
	417	procedure UpdateInsertsDialogs;
	418	procedure AutoLongLines(Sender: TObject);
[829]	419	//procedure UpdatePersonalObjects;
[456]	420	procedure UpdateApply(Template: TTemplate);
	421	procedure TemplateLocked(Sender: TObject);
	422	procedure InitTrees;
[829]	423	procedure AdjustControls4FontChange;
	424	procedure ShowGroupBoilerplate(Visible: boolean);
[456]	425	function GetLinkType(const ANode: TTreeNode): TTemplateLinkType;
	426	end;
	427
	428	procedure EditTemplates(Form: TForm; NewTemplate: boolean = FALSE; CopiedText: string = ''; Shared: boolean = FALSE);
	429
[829]	430	const
	431	TemplateEditorSplitters = 'frmTempEditSplitters';
	432	TemplateEditorSplitters2 = 'frmTempEditSplitters2';
	433
	434	var
	435	tmplEditorSplitterMiddle: integer = 0;
	436	tmplEditorSplitterProperties: integer = 0;
	437	tmplEditorSplitterMain: integer = 0;
	438	tmplEditorSplitterBoil: integer = 0;
	439	tmplEditorSplitterNotes: integer = 0;
	440
[456]	441	implementation
	442
	443	{$R *.DFM}
	444
	445	uses dShared, uCore, rTemplates, fTemplateObjects, uSpell, fTemplateView,
	446	fTemplateAutoGen, fDrawers, fTemplateFieldEditor, fTemplateFields, XMLUtils,
[829]	447	fIconLegend, uReminders, uConst, rCore, rEventHooks, rConsults, VAUtils,
	448	rMisc, fFindingTemplates;
[456]	449
	450	const
	451	PropText = ' Template Properties ';
	452	// GroupTag = 5;
	453	BPDisplayOnlyFld = 0;
	454	BPFirstLineFld = 1;
	455	BPOneItemOnlyFld = 2;
	456	BPHideDlgItemsFld = 3;
	457	BPHideItemsFld = 4;
	458	BPIndentFld = 5;
	459	BPLockFld = 6;
	460	NoIE5 = 'You must have Internet Explorer 5 or better installed to %s Templates';
	461	NoIE5Header = 'Need Internet Explorer 5';
	462	VK_A = Ord('A');
	463	VK_C = Ord('C');
	464	VK_E = Ord('E');
	465	VK_F = Ord('F');
	466	VK_G = Ord('G');
	467	VK_I = Ord('I');
	468	VK_S = Ord('S');
	469	VK_T = Ord('T');
	470	VK_V = Ord('V');
	471	VK_X = Ord('X');
	472	VK_Z = Ord('Z');
	473
	474	type
	475	TTypeIndex = (tiTemplate, tiFolder, tiGroup, tiDialog, tiRemDlg, tiCOMObj);
	476
	477	const
	478	tiNone = TTypeIndex(-1);
	479	// TypeTag: array[TTypeIndex] of integer = (7, 6, 8, -8, 7, 7);
	480	ttDialog = TTemplateType(-ord(ttGroup));
	481
	482	TypeTag: array[TTypeIndex] of TTemplateType = (ttDoc, ttClass, ttGroup, ttDialog, ttDoc, ttDoc);
	483	ForcedIdx: array[boolean, TTypeIndex] of integer = ((0,1,2,3,4,5),(-1,0,1,2,-1,-1));
	484	IdxForced: array[boolean, 0..5] of TTypeIndex = ((tiTemplate, tiFolder, tiGroup, tiDialog, tiRemDlg, tiCOMObj),
	485	(tiFolder, tiGroup, tiDialog, tiNone, tiNone, tiNone));
	486	iMessage = 'This template has one or more new fields, and you are not authorized to create new fields. ' +
	487	'If you continue, the program will import the new template without the new fields. Do you wish ' +
	488	'to do this?';
	489	iMessage2 = 'The imported template fields had XML errors. ';
	490	iMessage3 = 'No Fields were imported.';
	491
	492	var
	493	frmTemplateObjects: TfrmTemplateObjects = nil;
	494	frmTemplateFields: TfrmTemplateFields = nil;
	495
	496	procedure EditTemplates(Form: TForm; NewTemplate: boolean = FALSE;
	497	CopiedText: string = ''; Shared: boolean = FALSE);
	498	var
	499	frmTemplateEditor: TfrmTemplateEditor;
	500	Drawers: TFrmDrawers;
	501	ExpandStr, SelectStr: string;
	502	SelNode: TTreeNode;
	503	SelShared: boolean;
	504
	505	begin
	506	if(UserTemplateAccessLevel in [taReadOnly, taNone]) then exit;
	507
	508	ExpandStr := '';
	509	SelectStr := '';
	510	Drawers := nil;
	511	if(not NewTemplate) and (CopiedText = '') then
	512	begin
	513	if Form is TfrmDrawers then
	514	Drawers := TFrmDrawers(Form)
	515	else
[829]	516	if IsPublishedProp(Form, DrawersProperty) then
	517	Drawers := TFrmDrawers(GetOrdProp(Form, DrawersProperty));
[456]	518	end;
	519
	520	if assigned(Drawers) then
	521	begin
	522	ExpandStr := Drawers.tvTemplates.GetExpandedIDStr(1, ';');
	523	SelectStr := Drawers.tvTemplates.GetNodeID(TORTreeNode(Drawers.tvTemplates.Selected),1,';');
	524	end;
	525
	526	frmTemplateEditor := TfrmTemplateEditor.Create(Application);
	527	try
	528	with frmTemplateEditor do
	529	begin
	530	Font := Form.Font;
	531	reBoil.Font.Size := Form.Font.Size;
	532	reGroupBP.Font.Size := Form.Font.Size;
	533	reNotes.Font.Size := Form.Font.Size;
	534	dmodShared.ExpandTree(tvShared, ExpandStr, FSharedEmptyNodeCount);
	535	SelNode := tvShared.FindPieceNode(SelectStr,1,';');
	536	SelShared := assigned(SelNode);
	537	dmodShared.ExpandTree(tvPersonal, ExpandStr, FPersonalEmptyNodeCount);
	538	if not SelShared then
	539	SelNode := tvPersonal.FindPieceNode(SelectStr,1,';');
	540
	541	if(SelShared and (not Shared)) then
	542	Shared := TRUE;
	543
	544	if(Shared and (UserTemplateAccessLevel = taEditor)) then
	545	begin
	546	cbEditShared.Checked := TRUE;
	547	ActiveControl := tvShared;
	548	if SelShared then
	549	tvShared.Selected := SelNode
	550	else
	551	tvShared.Selected := tvShared.Items.GetFirstNode;
	552	end
	553	else
	554	if(not SelShared) and (assigned(SelNode)) then
	555	tvPersonal.Selected := SelNode;
	556	if(NewTemplate) then
	557	begin
	558	btnNewClick(frmTemplateEditor);
	559	if(CopiedText <> '') then
	560	begin
	561	TTemplate(FBtnNewNode.Data).Boilerplate := CopiedText;
	562	ShowInfo(FBtnNewNode);
	563	end;
	564	end;
	565	ShowModal;
	566	end;
	567	finally
	568	frmTemplateEditor.Free;
	569	end;
	570	end;
	571
	572	procedure TfrmTemplateEditor.btnNewClick(Sender: TObject);
	573	var
	574	idx: integer;
	575	Tmp, Owner: TTemplate;
	576	Node, PNode: TTreeNode;
	577	ownr: string;
	578	ok: boolean;
	579	ACheckBox: TCheckBox;
	580
	581	begin
	582	if((assigned(FCurTree)) and (assigned(FCurTree.Selected))) then
	583	begin
	584	if(FCurTree = tvShared) and (FCanEditShared) then
	585	ok := TRUE
	586	else
	587	if(FCurTree = tvPersonal) and (FCanEditPersonal) then
	588	ok := TRUE
	589	else
	590	ok := FALSE;
	591	if(ok) then
	592	begin
	593	Node := FCurTree.Selected;
	594	PNode := Node;
	595	if(TTemplate(Node.Data).RealType = ttDoc) then
	596	PNode := Node.Parent;
	597	if CanClone(PNode) then
	598	begin
	599	Clone(PNode);
	600	Owner := TTemplate(PNode.Data);
	601	if assigned(Owner) and Owner.CanModify then
	602	begin
	603	if Node = PNode then
	604	idx := 0
	605	else
	606	idx := Owner.Items.IndexOf(Node.Data) + 1;
	607	if(FCurTree = tvShared) then
	608	begin
	609	ownr := '';
	610	ACheckBox := cbShHide;
	611	end
	612	else
	613	begin
	614	ownr := IntToStr(User.DUZ);
	615	ACheckBox := cbPerHide;
	616	end;
	617	if FImportingFromXML then
	618	begin
	619	Tmp := TTemplate.CreateFromXML(FXMLTemplateElement, ownr);
	620	ACheckBox.Checked := ACheckBox.Checked and Tmp.Active;
	621	end
	622	else
	623	begin
	624	Tmp := TTemplate.Create('0^T^A^'+NewTemplateName+'^^^'+ownr);
	625	Tmp.BackupItems;
	626	Templates.AddObject(Tmp.ID, Tmp);
	627	end;
	628	btnApply.Enabled := TRUE;
	629	if(idx >= Owner.Items.Count) then
	630	Owner.Items.Add(Tmp)
	631	else
	632	Owner.Items.Insert(idx, Tmp);
	633	Resync([Owner]);
	634	Node := FCurTree.Selected;
	635	if(Node.Data <> Tmp) then
	636	begin
	637	if(TTemplate(Node.Data).RealType = ttDoc) then
	638	Node := Node.GetNextSibling
	639	else
	640	begin
	641	Node.Expand(FALSE);
	642	Node := Node.GetFirstChild;
	643	end;
	644	FCurTree.Selected := Node;
	645	end;
	646	FBtnNewNode := Node;
	647	if(FFirstShow) then
	648	FFocusName := TRUE
	649	else
	650	begin
	651	edtName.SetFocus;
	652	edtName.SelectAll;
	653	end;
	654	end;
	655	end;
	656	end;
	657	end;
	658	end;
	659
	660	procedure TfrmTemplateEditor.btnApplyClick(Sender: TObject);
	661	begin
	662	if(ScanNames) then
	663	begin
	664	SaveAllTemplates;
	665	BtnApply.Enabled := BackupDiffers;
	666	if not BtnApply.Enabled then
	667	UnlockAllTemplates;
	668	end;
	669	end;
	670
	671	procedure TfrmTemplateEditor.FormCreate(Sender: TObject);
	672	begin
	673	ResizeAnchoredFormToFont(self);
	674	//Now fix everything the resize messed up
	675	lblLines.Width := cbLock.Left - lblLines.Left - 15;
	676	sbPerDelete.Left := pnlPersonalBottom.ClientWidth - sbPerDelete.Width - 1;
	677	sbPerDown.Left := sbPerDelete.Left - sbPerDown.Width - 2;
	678	sbPerUp.Left := sbPerDown.Left - sbPerUp.Width - 2;
	679	cbPerHide.Width := sbPerUp.Left - 3;
	680	btnPerFind.Left := pnlPerSearch.ClientWidth - btnPerFind.Width;
	681
	682	FSavePause := Application.HintHidePause;
	683	Application.HintHidePause := FSavePause*2;
	684	if InteractiveRemindersActive then
	685	begin
	686	QuickCopy(GetTemplateAllowedReminderDialogs, cbxRemDlgs.Items);
	687	FCanDoReminders := (cbxRemDlgs.Items.Count > 0);
	688	end
	689	else
	690	FCanDoReminders := FALSE;
	691
	692	QuickCopy(GetAllActiveCOMObjects, cbxCOMObj.Items);
	693	FCanDoCOMObjects := (cbxCOMObj.Items.Count > 0);
	694
	695	FUpdating := TRUE;
	696	FFirstShow := TRUE;
	697
	698	FTreeControl[ttShared, tcDel] := sbShDelete;
	699	FTreeControl[ttShared, tcUp] := sbShUp;
	700	FTreeControl[ttShared, tcDown] := sbShDown;
	701	FTreeControl[ttShared, tcLbl] := lblCopy;
	702	FTreeControl[ttShared, tcCopy] := sbCopyRight;
	703	FTreeControl[ttPersonal, tcDel] := sbPerDelete;
	704	FTreeControl[ttPersonal, tcUp] := sbPerUp;
	705	FTreeControl[ttPersonal, tcDown] := sbPerDown;
	706	FTreeControl[ttPersonal, tcLbl] := lblCopy;
	707	FTreeControl[ttPersonal, tcCopy] := sbCopyLeft;
	708	dmodShared.InEditor := TRUE;
	709	dmodShared.OnTemplateLock := TemplateLocked;
	710
	711	gbProperties.Caption := PropText;
	712	pnlShSearch.Visible := FALSE;
	713	pnlPerSearch.Visible := FALSE;
	714	FCanEditPersonal := TRUE;
	715
	716	{ Don't mess with the order of the following commands! }
	717	InitTrees;
	718
	719	tvPersonal.Selected := tvPersonal.Items.GetFirstNode;
	720
	721	ClearBackup;
	722
	723	cboOwner.SelText := MixedCase(User.Name);
	724	NewPersonalUser(User.DUZ);
	725
	726	cbEditShared.Visible := (UserTemplateAccessLevel = taEditor);
	727	FCanEditShared := FALSE;
	728	SharedEditing;
	729
	730	HideControls;
	731
	732	lblCopy.AutoSize := TRUE;
	733	lblCopy.AutoSize := FALSE; // resets height based on font
	734	lblCopy.Width := pnlCopyBtns.Width + splMiddle.Width;
	735	MoveCopyButtons;
	736
	737	cbShHide.Checked := TRUE;
	738	cbPerHide.Checked := TRUE;
	739
	740	BtnApply.Enabled := BackupDiffers;
[829]	741	SetFormPosition(Self);
[456]	742	end;
	743
	744	procedure TfrmTemplateEditor.HideControls;
	745	begin
	746	sbCopyRight.Visible := FCanEditPersonal;
	747	if(not FCanEditPersonal) then
	748	cbPerHide.Checked := TRUE;
	749	cbPerHide.Visible := FCanEditPersonal;
	750	sbPerDelete.Visible := FCanEditPersonal;
	751	sbPerUp.Visible := FCanEditPersonal;
	752	sbPerDown.Visible := FCanEditPersonal;
	753	tvPersonal.ReadOnly := not FCanEditPersonal;
	754	MoveCopyButtons;
	755	end;
	756
	757	procedure TfrmTemplateEditor.cboOwnerNeedData(Sender: TObject;
	758	const StartFrom: String; Direction, InsertAt: Integer);
	759	begin
	760	// cboOwner.ForDataUse(SubSetOfTemplateOwners(StartFrom, Direction));
	761	end;
	762
	763	procedure TfrmTemplateEditor.cboOwnerChange(Sender: TObject);
	764	begin
	765	NewPersonalUser(cboOwner.ItemIEN);
	766	end;
	767
	768	procedure TfrmTemplateEditor.NewPersonalUser(UsrIEN: Int64);
	769	var
	770	NewEdit: boolean;
	771
	772	begin
	773	FCurrentPersonalUser := UsrIEN;
	774	NewEdit := (FCurrentPersonalUser = User.DUZ);
	775	if(FCanEditPersonal <> NewEdit) then
	776	begin
	777	FCanEditPersonal := NewEdit;
	778	HideControls;
	779	end;
	780	end;
	781
	782	procedure TfrmTemplateEditor.tvPersonalExpanding(Sender: TObject;
	783	Node: TTreeNode; var AllowExpansion: Boolean);
	784	begin
	785	AllowExpansion := dmodShared.ExpandNode(tvPersonal, Node,
	786	FPersonalEmptyNodeCount, not cbPerHide.Checked);
	787	if(AllowExpansion and FInternalHiddenExpand) then
	788	AllowExpansion := FALSE;
	789	end;
	790
	791	procedure TfrmTemplateEditor.tvSharedExpanding(Sender: TObject;
	792	Node: TTreeNode; var AllowExpansion: Boolean);
	793	begin
	794	AllowExpansion := dmodShared.ExpandNode(tvShared, Node,
	795	FSharedEmptyNodeCount, not cbShHide.Checked);
	796	if(AllowExpansion and FInternalHiddenExpand) then
	797	AllowExpansion := FALSE;
	798	end;
	799
	800	procedure TfrmTemplateEditor.tvTreeGetImageIndex(Sender: TObject;
	801	Node: TTreeNode);
	802	begin
	803	Node.ImageIndex := dmodShared.ImgIdx(Node);
	804	end;
	805
	806	procedure TfrmTemplateEditor.tvTreeGetSelectedIndex(Sender: TObject;
	807	Node: TTreeNode);
	808	begin
	809	Node.SelectedIndex := dmodShared.ImgIdx(Node);
	810	end;
	811
	812	function TfrmTemplateEditor.IsTemplateLocked(Node: TTreeNode): boolean;
	813	var
	814	Template: TTemplate;
	815
	816	begin
	817	Result := FALSE;
	818	if assigned(Node) then
	819	begin
	820	Template := TTemplate(Node.Data);
	821	if Template.AutoLock then
	822	Result := TRUE
	823	else
	824	if (Template.PersonalOwner = 0) then
	825	begin
	826	if RootTemplate.IsLocked then
	827	Result := TRUE
	828	else
	829	begin
	830	Result := TTemplate(Node.Data).IsLocked;
	831	if (not Result) and assigned(Node.Parent) and
	832	(TTemplate(Node.Parent).PersonalOwner = 0) then
	833	Result := IsTemplateLocked(Node.Parent);
	834	end;
	835	end;
	836	end;
	837	end;
	838
	839	procedure TfrmTemplateEditor.tvTreeChange(Sender: TObject;
	840	Node: TTreeNode);
	841	var
	842	ok, Something: boolean;
	843	Template: TTemplate;
	844
	845	begin
	846	ChangeTree(TTreeView(Sender));
	847	Something := assigned(Node);
	848	if Something then
	849	begin
	850	Template := TTemplate(Node.Data);
	851	Something := assigned(Template);
	852	if Something then
	853	begin
	854	if(Sender = tvPersonal) then
	855	begin
	856	ok := FCanEditPersonal;
	857	if ok and (Template.PersonalOwner = 0) and IsTemplateLocked(Node) then
	858	ok := FALSE;
	859	end
	860	else
	861	ok := FCanEditShared;
	862	EnableControls(ok, (Template.RealType in AllTemplateRootTypes));
	863	ShowInfo(Node);
	864	end;
	865	end;
	866	if not Something then
	867	begin
	868	gbProperties.Caption := PropText;
	869	EnableControls(FALSE, FALSE);
	870	ShowInfo(nil);
	871	end;
	872	end;
	873
	874	procedure TfrmTemplateEditor.EnableControls(ok, Root: boolean);
	875	begin
	876	cbLock.Enabled := ok and (FCurTree = tvShared);
	877	if(ok and Root) then
	878	begin
	879	ok := FALSE;
	880	lblName.Enabled := TRUE;
	881	edtName.Enabled := TRUE;
	882	reNotes.ReadOnly := FALSE;
	883	end
	884	else
	885	begin
	886	lblName.Enabled := ok;
	887	edtName.Enabled := ok;
	888	reNotes.ReadOnly := not ok;
	889	end;
	890	lblNotes.Enabled := (not reNotes.ReadOnly);
[829]	891	UpdateReadOnlyColorScheme(reNotes, reNotes.ReadOnly);
[456]	892	cbxType.Enabled := ok;
	893	lblType.Enabled := ok;
	894	lblRemDlg.Enabled := ok;
	895	cbxRemDlgs.Enabled := ok and FCanDoReminders;
	896	cbActive.Enabled := ok;
	897	cbExclude.Enabled := ok;
	898	cbDisplayOnly.Enabled := ok;
	899	cbFirstLine.Enabled := ok;
	900	cbOneItemOnly.Enabled := ok;
	901	cbHideDlgItems.Enabled := ok;
	902	cbHideItems.Enabled := ok;
	903	cbIndent.Enabled := ok;
	904	edtGap.Enabled := ok;
	905	udGap.Enabled := ok;
	906	udGap.Invalidate;
	907	lblLines.Enabled := ok;
	908	reBoil.ReadOnly := not ok;
[829]	909	UpdateReadOnlyColorScheme(reBoil, not ok);
[456]	910	lblLink.Enabled := ok;
	911	cbxLink.Enabled := ok;
	912	ok := ok and FCanDoCOMObjects;
	913	cbxCOMObj.Enabled := ok;
	914	lblCOMObj.Enabled := ok;
	915	edtCOMParam.Enabled := ok;
	916	lblCOMParam.Enabled := ok;
	917	UpdateInsertsDialogs;
	918	EnableNavControls;
	919	end;
	920
	921	procedure TfrmTemplateEditor.MoveCopyButtons;
	922	var
	923	tmpHeight: integer;
	924
	925	begin
	926	tmpHeight := tvShared.Height;
	927	dec(tmpHeight,lblCopy.Height);
	928	if(sbCopyLeft.Visible) then
	929	dec(tmpHeight, sbCopyLeft.Height+5);
	930	if(sbCopyRight.Visible) then
	931	dec(tmpHeight, sbCopyRight.Height+5);
	932	tmpHeight := (tmpHeight div 2) + tvShared.Top;
	933	lblCopy.Top := tmpHeight;
	934	inc(tmpHeight,lblCopy.height+5);
	935	if(sbCopyLeft.Visible) then
	936	begin
	937	sbCopyLeft.Top := tmpHeight;
	938	inc(tmpHeight, sbCopyLeft.Height+5);
	939	end;
	940	if(sbCopyRight.Visible) then
	941	sbCopyRight.Top := tmpHeight;
	942	end;
	943
	944	procedure TfrmTemplateEditor.splMainMoved(Sender: TObject);
	945	begin
	946	MoveCopyButtons;
	947	end;
	948
[829]	949	procedure TfrmTemplateEditor.ShowGroupBoilerplate(Visible: boolean);
	950	begin
	951	pnlGroupBP.Visible := Visible;
	952	splBoil.Visible := Visible;
	953	if Visible then
	954	begin
	955	reBoil.Align := alTop;
	956	pnlGroupBP.Align := alClient;
	957	reBoil.Height := tmplEditorSplitterBoil;
	958	splBoil.Top := pnlGroupBP.Top - splBoil.Height;
	959	end
	960	else
	961	begin
	962	pnlGroupBP.Align := alBottom;
	963	reBoil.Align := alClient;
	964	end;
	965	end;
	966
[456]	967	procedure TfrmTemplateEditor.ShowInfo(Node: TTreeNode);
	968	var
	969	OldUpdating, ClearName, ClearRB, ClearAll: boolean;
	970	Idx: TTypeIndex;
	971	CanDoCOM: boolean;
	972	lt: TTemplateLinkType;
	973	lts: string;
	974
	975	begin
	976	OldUpdating := FUpdating;
	977	FUpdating := TRUE;
	978	try
	979	if(assigned(Node)) then
	980	begin
	981	FShowingTemplate := TTemplate(Node.Data);
	982	with FShowingTemplate do
	983	begin
	984	ClearName := FALSE;
	985	ClearRB := FALSE;
	986	ClearAll := FALSE;
	987	ShowTemplateType(TTemplate(Node.Data));
	988	lt := GetLinkType(Node);
	989	if(lt = ltNone) or (IsReminderDialog and (not (lt in [ltNone, ltTitle]))) then
	990	pnlLink.Visible := FALSE
	991	else
	992	begin
	993	pnlLink.Visible := TRUE;
	994	pnlLink.Tag := ord(lt);
	995	case lt of
	996	ltTitle: lts := 'Title';
	997	ltConsult: lts := 'Consult Service';
	998	ltProcedure: lts := 'Procedure';
	999	else lts := '';
	1000	end;
	1001	cbxLink.Clear;
	1002	if lt = ltConsult then
	1003	begin
	1004	cbxLink.LongList := FALSE;
	1005	if not assigned(FConsultServices) then
	1006	begin
	1007	FConsultServices := TStringList.Create;
[829]	1008	FastAssign(LoadServiceListWithSynonyms(1), FConsultServices);
[456]	1009	SortByPiece(FConsultServices, U, 2);
	1010	end;
[829]	1011	FastAssign(FConsultServices, cbxLink.Items);
[456]	1012	end
	1013	else
	1014	begin
	1015	cbxLink.LongList := TRUE;
	1016	cbxLink.HideSynonyms := TRUE;
	1017	cbxLink.InitLongList(LinkName);
	1018	end;
	1019	cbxLink.SelectByID(LinkIEN);
	1020	lblLink.Caption := ' Associated ' + lts + ': ';
	1021	cbxLink.Caption := lblLink.Caption;
	1022	end;
	1023
	1024	edtName.Text := PrintName;
	1025	reNotes.Lines.Text := Description;
	1026	if(PersonalOwner = 0) and (FCurTree = tvShared) and (cbEditShared.Checked) then
	1027	begin
	1028	cbLock.Checked := IsLocked;
	1029	if AutoLock then
	1030	cbLock.Enabled := FALSE;
	1031	end
	1032	else
	1033	begin
	1034	cbLock.Checked := IsTemplateLocked(Node);
	1035	cbLock.Enabled := FALSE;
	1036	end;
	1037	CanDoCom := FCanDoCOMObjects and (PersonalOwner = 0);
	1038	if(RealType in AllTemplateRootTypes) then
	1039	begin
	1040	ClearRB := TRUE;
	1041	ClearAll := TRUE;
	1042	end
	1043	else
	1044	begin
	1045	case RealType of
	1046	ttDoc: begin
	1047	if IsReminderDialog then
	1048	Idx := tiRemDlg
	1049	else
	1050	if IsCOMObject then
	1051	Idx := tiCOMObj
	1052	else
	1053	Idx := tiTemplate;
	1054	end;
	1055	ttGroup: begin
	1056	if(Dialog) then
	1057	Idx := tiDialog
	1058	else
	1059	Idx := tiGroup;
	1060	end;
	1061	ttClass: Idx := tiFolder;
	1062	else Idx := tiNone;
	1063	end;
	1064	FForceContainer := ((RealType in [ttGroup, ttClass]) and (Children <> tcNone));
	1065	cbxType.Items.Clear;
	1066	if not FForceContainer then
	1067	cbxType.Items.Add('Template');
	1068	cbxType.Items.Add('Folder');
	1069	cbxType.Items.Add('Group Template');
	1070	cbxType.Items.Add('Dialog');
	1071	if (not FForceContainer) then
	1072	begin
	1073	if(FCanDoReminders or CanDoCOM) then
	1074	cbxType.Items.Add('Reminder Dialog');
	1075	if(CanDoCOM) then
	1076	cbxType.Items.Add('COM Object');
	1077	end;
	1078	cbxType.ItemIndex := ForcedIdx[FForceContainer, Idx];
	1079	if(Idx = tiRemDlg) and FCanDoReminders then
	1080	cbxRemDlgs.SelectByID(ReminderDialogIEN)
	1081	else
	1082	begin
	1083	lblRemDlg.Enabled := FALSE;
	1084	cbxRemDlgs.Enabled := FALSE;
	1085	cbxRemDlgs.ItemIndex := -1;
	1086	end;
	1087	if (Idx = tiCOMObj) and CanDoCOM then
	1088	begin
	1089	pnlCOM.Visible := TRUE;
	1090	cbxCOMObj.SelectByIEN(COMObject);
	1091	edtCOMParam.Text := COMParam;
	1092	end
	1093	else
	1094	begin
	1095	pnlCOM.Visible := FALSE;
	1096	cbxCOMObj.ItemIndex := -1;
	1097	edtCOMParam.Text := '';
	1098	end;
	1099	cbActive.Checked := Active;
	1100	if(RealType in [ttClass, ttGroup]) then
	1101	cbHideItems.Checked := HideItems
	1102	else
	1103	begin
	1104	cbHideItems.Checked := FALSE;
	1105	cbHideItems.Enabled := FALSE;
	1106	end;
	1107	if((RealType in [ttDoc, ttGroup]) and (assigned(Node.Parent)) and
	1108	(TTemplate(Node.Parent.Data).RealType = ttGroup) and
	1109	(not IsReminderDialog) and (not IsCOMObject)) then
	1110	cbExclude.Checked := Exclude
	1111	else
	1112	begin
	1113	cbExclude.Checked := FALSE;
	1114	cbExclude.Enabled := FALSE;
	1115	end;
	1116	if dmodShared.InDialog(Node) and (not IsReminderDialog) and (not IsCOMObject) then
	1117	begin
	1118	cbDisplayOnly.Checked := DisplayOnly;
	1119	cbFirstLine.Checked := FirstLine;
	1120	end
	1121	else
	1122	begin
	1123	cbDisplayOnly.Checked := FALSE;
	1124	cbDisplayOnly.Enabled := FALSE;
	1125	cbFirstLine.Checked := FALSE;
	1126	cbFirstLine.Enabled := FALSE;
	1127	end;
	1128	if(RealType in [ttGroup, ttClass]) and (Children <> tcNone) and
	1129	(dmodShared.InDialog(Node)) then
	1130	begin
	1131	cbOneItemOnly.Checked := OneItemOnly;
	1132	cbIndent.Checked := IndentItems;
	1133	if(RealType = ttGroup) and (Boilerplate <> '') then
	1134	begin
	1135	cbHideDlgItems.Checked := HideDlgItems;
	1136	end
	1137	else
	1138	begin
	1139	cbHideDlgItems.Checked := FALSE;
	1140	cbHideDlgItems.Enabled := FALSE;
	1141	end;
	1142	end
	1143	else
	1144	begin
	1145	cbOneItemOnly.Checked := FALSE;
	1146	cbOneItemOnly.Enabled := FALSE;
	1147	cbHideDlgItems.Checked := FALSE;
	1148	cbHideDlgItems.Enabled := FALSE;
	1149	cbIndent.Checked := FALSE;
	1150	cbIndent.Enabled := FALSE;
	1151	end;
	1152	if(RealType = ttGroup) then
	1153	edtGap.Text := IntToStr(Gap)
	1154	else
	1155	begin
	1156	edtGap.Text := '0';
	1157	edtGap.Enabled := FALSE;
	1158	udGap.Enabled := FALSE;
	1159	udGap.Invalidate;
	1160	lblLines.Enabled := FALSE;
	1161	end;
	1162	DisplayBoilerPlate(Node);
	1163	end;
	1164	end;
	1165	end
	1166	else
	1167	begin
	1168	ClearAll := TRUE;
	1169	ClearRB := TRUE;
	1170	ClearName := TRUE;
	1171	gbProperties.Caption := PropText;
	1172	end;
	1173	if(ClearName) then
	1174	begin
	1175	edtName.Text := '';
	1176	reNotes.Clear;
	1177	end;
	1178	if(ClearRB) then
	1179	begin
	1180	cbxType.ItemIndex := Ord(tiNone);
	1181	end;
	1182	if(ClearAll) then
	1183	begin
	1184	cbActive.Checked := FALSE;
	1185	cbExclude.Checked := FALSE;
	1186	cbDisplayOnly.Checked := FALSE;
	1187	cbFirstLine.Checked := FALSE;
	1188	cbOneItemOnly.Checked := FALSE;
	1189	cbHideDlgItems.Checked := FALSE;
	1190	cbHideItems.Checked := FALSE;
	1191	cbIndent.Checked := FALSE;
	1192	edtGap.Text := '0';
	1193	reBoil.Clear;
[829]	1194	ShowGroupBoilerplate(False);
[456]	1195	pnlBoilerplateResize(Self);
	1196	pnlCOM.Visible := FALSE;
	1197	pnlLink.Visible := FALSE;
	1198	end;
	1199	if cbDisplayOnly.Enabled or
	1200	cbFirstLine.Enabled or
	1201	cbIndent.Enabled or
	1202	cbOneItemOnly.Enabled or
	1203	cbHideDlgItems.Enabled then
	1204	gbDialogProps.Font.Color := clWindowText
	1205	else
	1206	gbDialogProps.Font.Color := clInactiveCaption;
	1207	finally
	1208	FUpdating := OldUpdating;
	1209	end;
	1210	end;
	1211
	1212	procedure TfrmTemplateEditor.pnlBoilerplateResize(Sender: TObject);
	1213	var
	1214	Max: integer;
	1215
	1216	begin
	1217	if(pnlGroupBP.Visible) and (pnlGroupBP.Height > (pnlBoilerplate.Height-29)) then
[829]	1218	begin
[456]	1219	pnlGroupBP.Height := pnlBoilerplate.Height-29;
[829]	1220	end;
[456]	1221	if cbLongLines.checked then
	1222	Max := 240
	1223	else
	1224	Max := MAX_ENTRY_WIDTH;
	1225	LimitEditWidth(reBoil, Max);
	1226	LimitEditWidth(reNotes, MAX_ENTRY_WIDTH);
	1227	end;
	1228
	1229	procedure TfrmTemplateEditor.edtNameOldChange(Sender: TObject);
	1230	var
	1231	i: integer;
	1232	Template: TTemplate;
	1233	DoRefresh: boolean;
	1234
	1235	begin
	1236	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected))) then
	1237	begin
	1238	if CanClone(FCurTree.Selected) then
	1239	begin
	1240	DoRefresh := Clone(FCurTree.Selected);
	1241	Template := TTemplate(FCurTree.Selected.Data);
	1242	if assigned(Template) and Template.CanModify then
	1243	begin
	1244	Template.PrintName := edtName.Text;
	1245	UpdateApply(Template);
	1246	for i := 0 to Template.Nodes.Count-1 do
	1247	TTreeNode(Template.Nodes.Objects[i]).Text := Template.PrintName;
	1248	if(DoRefresh) then
	1249	begin
	1250	tvShared.Invalidate;
	1251	tvPersonal.Invalidate;
	1252	end;
	1253	end;
	1254	end;
	1255	end;
	1256	end;
	1257
	1258	procedure TfrmTemplateEditor.cbActiveClick(Sender: TObject);
	1259	var
	1260	i: integer;
	1261	Template: TTemplate;
	1262	Node: TTreeNode;
	1263
	1264	begin
	1265	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected))) then
	1266	begin
	1267	if CanClone(FCurTree.Selected) then
	1268	begin
	1269	Clone(FCurTree.Selected);
	1270	Template := TTemplate(FCurTree.Selected.Data);
	1271	if assigned(Template) and Template.CanModify then
	1272	begin
	1273	Template.Active := cbActive.Checked;
	1274	UpdateApply(Template);
	1275	for i := 0 to Template.Nodes.Count-1 do
	1276	begin
	1277	Node := TTreeNode(Template.Nodes.Objects[i]);
	1278	Node.Cut := not Template.Active;
	1279	end;
	1280	if(FCurTree = tvShared) then
	1281	begin
	1282	cbPerHideClick(Sender);
	1283	cbShHideClick(Sender);
	1284	end
	1285	else
	1286	begin
	1287	cbShHideClick(Sender);
	1288	cbPerHideClick(Sender);
	1289	end;
	1290	tvTreeChange(FCurTree, FCurTree.Selected);
	1291	EnableNavControls;
	1292	if cbActive.CanFocus then
	1293	cbActive.SetFocus;
	1294	end;
	1295	end;
	1296	end;
	1297	end;
	1298
	1299	procedure TfrmTemplateEditor.cbExcludeClick(Sender: TObject);
	1300	var
	1301	i: integer;
	1302	Template: TTemplate;
	1303	Node: TTreeNode;
	1304
	1305	begin
	1306	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected))) then
	1307	begin
	1308	if CanClone(FCurTree.Selected) then
	1309	begin
	1310	Clone(FCurTree.Selected);
	1311	Template := TTemplate(FCurTree.Selected.Data);
	1312	if assigned(Template) and Template.CanModify then
	1313	begin
	1314	Template.Exclude := cbExclude.Checked;
	1315	UpdateApply(Template);
	1316	for i := 0 to Template.Nodes.Count-1 do
	1317	begin
	1318	Node := TTreeNode(Template.Nodes.Objects[i]);
	1319	Node.ImageIndex := dmodShared.ImgIdx(Node);
	1320	Node.SelectedIndex := dmodShared.ImgIdx(Node);
	1321	end;
	1322	tvShared.Invalidate;
	1323	tvPersonal.Invalidate;
	1324	end;
	1325	end;
	1326	end;
	1327	end;
	1328
	1329	procedure TfrmTemplateEditor.edtGapChange(Sender: TObject);
	1330	var
	1331	DoRefresh: boolean;
	1332	Template: TTemplate;
	1333
	1334	begin
	1335	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected))) then
	1336	begin
	1337	if CanClone(FCurTree.Selected) then
	1338	begin
	1339	DoRefresh := Clone(FCurTree.Selected);
	1340	Template := TTemplate(FCurTree.Selected.Data);
	1341	if assigned(Template) and Template.CanModify then
	1342	begin
	1343	Template.Gap := StrToIntDef(edtGap.Text, 0);
	1344	UpdateApply(Template);
	1345	DisplayBoilerPlate(FCurTree.Selected);
	1346	if(DoRefresh) then
	1347	begin
	1348	tvShared.Invalidate;
	1349	tvPersonal.Invalidate;
	1350	end;
	1351	end;
	1352	end;
	1353	end;
	1354	end;
	1355
	1356	function TfrmTemplateEditor.ChangeTree(NewTree: TTreeView): boolean;
	1357	var
	1358	i: TTemplateTreeControl;
	1359
	1360	begin
	1361	Result := FALSE;
	1362	tvShared.HideSelection := TRUE;
	1363	tvPersonal.HideSelection := TRUE;
	1364	if(NewTree <> FCurTree) then
	1365	begin
	1366	Result := TRUE;
	1367	if(assigned(FCurTree)) then
	1368	begin
	1369	for i := low(TTemplateTreeControl) to high(TTemplateTreeControl) do
	1370	FTreeControl[TTemplateTreeType(FCurTree.Tag), i].Enabled := FALSE;
	1371	end;
	1372	FCurTree := NewTree;
	1373	end;
	1374	if(assigned(FCurTree)) then
	1375	begin
	1376	FCurTree.HideSelection := FALSE;
	1377	if(FCurTree = tvPersonal) and (Screen.ActiveControl = tvShared) then
	1378	tvPersonal.SetFocus
	1379	else
	1380	if(FCurTree = tvShared) and (Screen.ActiveControl = tvPersonal) then
	1381	tvShared.SetFocus;
	1382	end;
	1383	end;
	1384
	1385	procedure TfrmTemplateEditor.tvTreeEnter(Sender: TObject);
	1386	begin
	1387	if((Sender is TTreeView) and (ChangeTree(TTreeView(Sender)))) then
	1388	tvTreeChange(Sender, TTreeView(Sender).Selected);
	1389	end;
	1390
	1391	procedure TfrmTemplateEditor.tvTreeNodeEdited(Sender: TObject;
	1392	Node: TTreeNode; var S: String);
	1393	begin
	1394	FUpdating := TRUE;
	1395	try
	1396	edtName.Text := S;
	1397	finally
	1398	FUpdating := FALSE;
	1399	end;
	1400	edtNameOldChange(edtName);
	1401	end;
	1402
	1403	procedure TfrmTemplateEditor.cbShHideClick(Sender: TObject);
	1404	var
	1405	Node: TTreeNode;
	1406
	1407	begin
	1408	Node := tvShared.Items.GetFirstNode;
	1409	while assigned(Node) do
	1410	begin
	1411	dmodShared.Resync(Node, not cbShHide.Checked, FSharedEmptyNodeCount);
	1412	Node := Node.getNextSibling;
	1413	end;
	1414	tvTreeChange(tvShared, tvShared.Selected);
	1415	EnableNavControls;
	1416	end;
	1417
	1418	procedure TfrmTemplateEditor.cbPerHideClick(Sender: TObject);
	1419	begin
	1420	dmodShared.Resync(tvPersonal.Items.GetFirstNode, not cbPerHide.Checked,
	1421	FPersonalEmptyNodeCount);
	1422	tvTreeChange(tvPersonal, tvPersonal.Selected);
	1423	EnableNavControls;
	1424	end;
	1425
	1426	procedure TfrmTemplateEditor.DisplayBoilerplate(Node: TTreeNode);
	1427	var
	1428	OldUpdating, ItemOK, BPOK, LongLines: boolean;
	1429	i: integer;
	1430	TmpSL: TStringList;
	1431
	1432	begin
	1433	OldUpdating := FUpdating;
	1434	FUpdating := TRUE;
	1435	try
	1436	pnlBoilerplateResize(pnlBoilerplate);
	1437	reBoil.Clear;
	1438	ItemOK := FALSE;
	1439	BPOK := TRUE;
	1440	with Node, TTemplate(Node.Data) do
	1441	begin
	1442	if(RealType in [ttDoc, ttGroup]) then
	1443	begin
	1444	TmpSL := TStringList.Create;
	1445	try
	1446	if(RealType = ttGroup) and (not reBoil.ReadOnly) then
	1447	begin
	1448	ItemOK := TRUE;
	1449	TmpSL.Text := Boilerplate;
	1450	reGroupBP.Clear;
	1451	reGroupBP.SelText := FullBoilerplate;
	1452	end
	1453	else
	1454	TmpSL.Text := FullBoilerplate;
	1455	LongLines := FALSE;
	1456	for i := 0 to TmpSL.Count-1 do
	1457	begin
	1458	if length(TmpSL[i]) > MAX_ENTRY_WIDTH then
	1459	begin
	1460	LongLines := TRUE;
	1461	break;
	1462	end;
	1463	end;
	1464	cbLongLines.Checked := LongLines;
	1465	reBoil.SelText := TmpSL.Text;
	1466	finally
	1467	TmpSL.Free;
	1468	end;
	1469	end
	1470	else
	1471	begin
	1472	reBoil.ReadOnly := TRUE;
[829]	1473	UpdateReadOnlyColorScheme(reBoil, TRUE);
[456]	1474	UpdateInsertsDialogs;
	1475	end;
[829]	1476	ShowGroupBoilerplate(ItemOK);
[456]	1477	if(not ItemOK) and (IsReminderDialog or IsCOMObject) then
	1478	BPOK := FALSE;
	1479	pnlBoilerplateResize(Self);
	1480	pnlBoilerplate.Visible := BPOK;
	1481	lblBoilerplate.Visible := BPOK;
	1482	pnlCOM.Visible := (not BPOK) and IsCOMObject;
	1483	end;
	1484	finally
	1485	FUpdating := OldUpdating;
	1486	end;
	1487	end;
	1488
	1489	procedure TfrmTemplateEditor.FormDestroy(Sender: TObject);
	1490	begin
	1491	KillObj(@FConsultServices);
	1492	Application.HintHidePause := FSavePause;
	1493	if(assigned(frmTemplateObjects)) then
	1494	begin
	1495	frmTemplateObjects.Free;
	1496	frmTemplateObjects := nil;
	1497	end;
	1498	if(assigned(frmTemplateFields)) then
	1499	begin
	1500	frmTemplateFields.Free;
	1501	frmTemplateFields := nil;
	1502	end;
[829]	1503	//---------- CQ #8665 - RV --------
	1504	//KillObj(@FPersonalObjects);
	1505	if (assigned(uPersonalObjects)) then
	1506	begin
	1507	KillObj(@uPersonalObjects);
	1508	uPersonalObjects.Free;
	1509	uPersonalObjects := nil;
	1510	end;
	1511	// ---- end CQ #8665 -------------
[456]	1512	dmodShared.OnTemplateLock := nil;
	1513	dmodShared.InEditor := FALSE;
	1514	RemoveAllNodes;
	1515	ClearBackup;
	1516	UnlockAllTemplates;
	1517	dmodShared.Reload;
	1518	end;
	1519
	1520	procedure TfrmTemplateEditor.sbMoveUpClick(Sender: TObject);
	1521	var
	1522	idx: integer;
	1523	ChangeLevel: boolean;
	1524	ParentsParent, ParentNode, Node: TTreeNode;
	1525	NodeTemplate, ParentTemplate, Template: TTemplate;
	1526	Hide, First, ok: boolean;
	1527
	1528	begin
	1529	if((assigned(FCurTree)) and (assigned(FCurTree.Selected)) and
	1530	(assigned(FCurTree.Selected.Parent))) then
	1531	begin
	1532	Node := FCurTree.Selected;
	1533	NodeTemplate := TTemplate(Node.Data);
	1534	ParentNode := Node.Parent;
	1535	Template := TTemplate(ParentNode.Data);
	1536	idx := Template.Items.IndexOf(NodeTemplate);
	1537	ChangeLevel := (idx < 1);
	1538	if(not ChangeLevel) then
	1539	begin
	1540	if(TTemplateTreeType(TBitBtn(Sender).Tag) = ttShared) then
	1541	Hide := cbShHide.Checked
	1542	else
	1543	Hide := cbPerHide.Checked;
	1544	First := TRUE;
	1545	while(idx > 0) do
	1546	begin
	1547	if First then
	1548	begin
	1549	ok := FALSE;
	1550	First := FALSE;
	1551	if CanClone(ParentNode) then
	1552	begin
	1553	if(Clone(ParentNode)) then
	1554	Template := TTemplate(ParentNode.Data);
	1555	if Template.CanModify then
	1556	ok := TRUE;
	1557	end;
	1558	end
	1559	else
	1560	ok := TRUE;
	1561	if ok then
	1562	begin
	1563	Template.Items.Exchange(idx-1, idx);
	1564	if(Hide and (not TTemplate(Template.Items[idx]).Active)) then
	1565	begin
	1566	dec(idx);
	1567	ChangeLevel := (idx < 1);
	1568	end
	1569	else
	1570	idx := 0;
	1571	end
	1572	else
	1573	idx := 0;
	1574	end;
	1575	end;
	1576	if(ChangeLevel) then
	1577	begin
	1578	ParentsParent := ParentNode.Parent;
	1579	if(assigned(ParentsParent)) then
	1580	begin
	1581	ParentTemplate := TTemplate(ParentsParent.Data);
	1582	if(ParentTemplate.Items.IndexOf(NodeTemplate) >= 0) then
	1583	InfoBox(ParentsParent.Text + ' already contains the ' +
	1584	NodeTemplate.PrintName + ' template.',
	1585	'Error', MB_OK or MB_ICONERROR)
	1586	else
	1587	begin
	1588	if CanClone(ParentNode) then
	1589	begin
	1590	if(Clone(ParentNode)) then
	1591	Template := TTemplate(ParentNode.Data);
	1592	if Template.CanModify and CanClone(ParentsParent) then
	1593	begin
	1594	if(Clone(ParentsParent)) then
	1595	ParentTemplate := TTemplate(ParentsParent.Data);
	1596	if ParentTemplate.CanModify then
	1597	begin
	1598	Template.Items.Delete(idx);
	1599	idx := ParentTemplate.Items.IndexOf(Template);
	1600	if(idx >= 0) then
	1601	begin
	1602	ParentTemplate.Items.Insert(idx, NodeTemplate);
	1603	Resync([ParentTemplate, Template]);
	1604	btnApply.Enabled := TRUE;
	1605	end;
	1606	end;
	1607	end;
	1608	end;
	1609	end;
	1610	end;
	1611	end
	1612	else
	1613	begin
	1614	Resync([Template]);
	1615	btnApply.Enabled := TRUE;
	1616	end;
	1617	end;
	1618	end;
	1619
	1620	procedure TfrmTemplateEditor.sbMoveDownClick(Sender: TObject);
	1621	var
	1622	max, idx: integer;
	1623	ChangeLevel: boolean;
	1624	ParentsParent, ParentNode, Node: TTreeNode;
	1625	NodeTemplate, ParentTemplate, Template: TTemplate;
	1626	Hide, First, ok: boolean;
	1627
	1628	begin
	1629	if((assigned(FCurTree)) and (assigned(FCurTree.Selected)) and
	1630	(assigned(FCurTree.Selected.Parent))) then
	1631	begin
	1632	Node := FCurTree.Selected;
	1633	NodeTemplate := TTemplate(Node.Data);
	1634	ParentNode := Node.Parent;
	1635	Template := TTemplate(ParentNode.Data);
	1636	idx := Template.Items.IndexOf(NodeTemplate);
	1637	max := Template.Items.Count-1;
	1638	ChangeLevel := (idx >= max);
	1639	if(not ChangeLevel) then
	1640	begin
	1641	if(TTemplateTreeType(TBitBtn(Sender).Tag) = ttShared) then
	1642	Hide := cbShHide.Checked
	1643	else
	1644	Hide := cbPerHide.Checked;
	1645	First := TRUE;
	1646	while(idx < max) do
	1647	begin
	1648	if First then
	1649	begin
	1650	ok := FALSE;
	1651	First := FALSE;
	1652	if CanClone(ParentNode) then
	1653	begin
	1654	if(Clone(ParentNode)) then
	1655	Template := TTemplate(ParentNode.Data);
	1656	if Template.CanModify then
	1657	ok := TRUE;
	1658	end;
	1659	end
	1660	else
	1661	ok := TRUE;
	1662	if ok then
	1663	begin
	1664	Template.Items.Exchange(idx, idx+1);
	1665	if(Hide and (not TTemplate(Template.Items[idx]).Active)) then
	1666	begin
	1667	inc(idx);
	1668	ChangeLevel := (idx >= max);
	1669	end
	1670	else
	1671	idx := max;
	1672	end
	1673	else
	1674	idx := max;
	1675	end;
	1676	end;
	1677	if(ChangeLevel) then
	1678	begin
	1679	ParentsParent := ParentNode.Parent;
	1680	if(assigned(ParentsParent)) then
	1681	begin
	1682	ParentTemplate := TTemplate(ParentsParent.Data);
	1683	if(ParentTemplate.Items.IndexOf(NodeTemplate) >= 0) then
	1684	InfoBox(ParentsParent.Text + ' already contains the ' +
	1685	NodeTemplate.PrintName + ' template.',
	1686	'Error', MB_OK or MB_ICONERROR)
	1687	else
	1688	begin
	1689	if CanClone(ParentNode) then
	1690	begin
	1691	if(Clone(ParentNode)) then
	1692	Template := TTemplate(ParentNode.Data);
	1693	if Template.CanModify and CanClone(ParentsParent) then
	1694	begin
	1695	if(Clone(ParentsParent)) then
	1696	ParentTemplate := TTemplate(ParentsParent.Data);
	1697	if ParentTemplate.CanModify then
	1698	begin
	1699	Template.Items.Delete(idx);
	1700	idx := ParentTemplate.Items.IndexOf(Template);
	1701	if(idx >= 0) then
	1702	begin
	1703	if(idx = (ParentTemplate.Items.Count-1)) then
	1704	ParentTemplate.Items.Add(NodeTemplate)
	1705	else
	1706	ParentTemplate.Items.Insert(idx+1, NodeTemplate);
	1707	Resync([ParentTemplate, Template]);
	1708	btnApply.Enabled := TRUE;
	1709	end;
	1710	end;
	1711	end;
	1712	end;
	1713	end;
	1714	end;
	1715	end
	1716	else
	1717	begin
	1718	Resync([Template]);
	1719	btnApply.Enabled := TRUE;
	1720	end;
	1721	end;
	1722	end;
	1723
	1724	procedure TfrmTemplateEditor.sbDeleteClick(Sender: TObject);
	1725	var
	1726	PNode, Node: TTreeNode;
	1727	Template, Parent: TTemplate;
	1728	DoIt: boolean;
	1729	Answer: Word;
	1730
	1731	begin
	1732	if((assigned(FCurTree)) and (assigned(FCurTree.Selected)) and
	1733	(assigned(FCurTree.Selected.Parent))) then
	1734	begin
	1735	Node := FCurTree.Selected;
	1736	Template := TTemplate(Node.Data);
	1737	PNode := Node.Parent;
	1738	Parent := TTemplate(PNode.Data);
	1739	if(AutoDel(Template)) then
	1740	DoIt := TRUE
	1741	else
	1742	if(Template.Active) and (cbActive.Checked) then
	1743	begin
	1744	DoIt := FALSE;
	1745	Answer := MessageDlg('Once you delete a template you may not be able to retrieve it.' + CRLF +
	1746	'Rather than deleting, you may want to inactivate a template instead.' + CRLF +
	1747	'You may inactivate this template by pressing the Ignore button now.' + CRLF +
	1748	'Are you sure you want to delete the "' + Node.Text +
	1749	'" Template?', mtConfirmation, [mbYes, mbNo, mbIgnore], 0);
	1750	if(Answer = mrYes) then
	1751	DoIt := TRUE
	1752	else
	1753	if(Answer = mrIgnore) then
	1754	cbActive.Checked := FALSE;
	1755	end
	1756	else
	1757	DoIt := InfoBox('Are you sure you want to delete the "' + Node.Text +
	1758	'" Template?', 'Confirmation', MB_YESNO or MB_ICONQUESTION) = IDYES;
	1759	if(DoIt and CanClone(PNode)) then
	1760	begin
	1761	if(Clone(PNode)) then
	1762	Parent := TTemplate(PNode.Data);
	1763	if assigned(Parent) and Parent.CanModify then
	1764	begin
	1765	btnApply.Enabled := TRUE;
	1766	Parent.RemoveChild(Template);
	1767	MarkDeleted(Template);
	1768	Resync([Parent]);
	1769	tvTreeChange(FCurTree, FCurTree.Selected);
	1770	end;
	1771	end;
	1772	end;
	1773	end;
	1774
	1775	procedure TfrmTemplateEditor.EnableNavControls;
	1776	var
	1777	i: TTemplateTreeControl;
	1778	AllowUp, AllowDown, AllowSet: boolean;
	1779	Node: TTreeNode;
	1780	Tree: TTemplateTreeType;
	1781	Curok: boolean;
	1782	OldActiveControl: TControl;
	1783	begin
	1784	if(Assigned(FCurTree)) then
	1785	begin
	1786	Tree := TTemplateTreeType(FCurTree.Tag);
	1787	Node := FCurTree.Selected;
	1788	if(Assigned(Node)) then
	1789	Curok := (TTemplate(Node.Data).RealType in [ttDoc, ttGroup, ttClass])
	1790	else
	1791	Curok := FALSE;
	1792	if(Curok) then
	1793	begin
	1794	OldActiveControl := ActiveControl;
	1795	FTreeControl[Tree, tcDel].Enabled := TRUE;
	1796	AllowSet := FALSE;
	1797	if(Node.Index > 0) then
	1798	AllowUp := TRUE
	1799	else
	1800	begin
	1801	AllowUp := AllowMove(Node.Parent.Parent, Node);
	1802	AllowSet := TRUE;
	1803	end;
	1804	FTreeControl[Tree, tcUp].Enabled := AllowUp;
	1805	AllowDown := AllowUp;
	1806	if(Node.Index < (Node.Parent.Count-1)) then
	1807	AllowDown := TRUE
	1808	else
	1809	begin
	1810	if(not AllowSet) then
	1811	AllowDown := AllowMove(Node.Parent.Parent, Node);
	1812	end;
	1813	FTreeControl[Tree, tcDown].Enabled := AllowDown;
	1814	if not AllowUp and (OldActiveControl = FTreeControl[Tree, tcUp]) then
	1815	(FTreeControl[Tree, tcDown] as TWinControl).SetFocus;
	1816	if not AllowDown and (OldActiveControl = FTreeControl[Tree, tcDown]) then
	1817	(FTreeControl[Tree, tcUp] as TWinControl).SetFocus;
	1818	FTreeControl[Tree, tcCopy].Enabled := FTreeControl[TTemplateTreeType(1-ord(Tree)), tcDel].Visible;
	1819	if(FTreeControl[Tree, tcCopy].Enabled) then
	1820	begin
	1821	if(Tree = ttShared) then
	1822	Node := tvPersonal.Selected
	1823	else
	1824	Node := tvShared.Selected;
	1825	if(assigned(Node)) then
	1826	begin
	1827	if(TTemplate(Node.Data).RealType = ttDoc) then
	1828	Node := Node.Parent;
	1829	FTreeControl[Tree, tcCopy].Enabled := AllowMove(Node, FCurTree.Selected);
	1830	end
	1831	else
	1832	FTreeControl[Tree, tcCopy].Enabled := FALSE;
	1833	end;
	1834	FTreeControl[Tree, tcLbl].Enabled := FTreeControl[Tree, tcCopy].Enabled;
	1835	end
	1836	else
	1837	begin
	1838	for i := low(TTemplateTreeControl) to high(TTemplateTreeControl) do
	1839	FTreeControl[Tree, i].Enabled := FALSE;
	1840	end;
	1841	if(FCurTree = tvShared) and (FCanEditShared) then
	1842	btnNew.Enabled := TRUE
	1843	else
	1844	if(FCurTree = tvPersonal) and (FCanEditPersonal) then
	1845	btnNew.Enabled := TRUE
	1846	else
	1847	btnNew.Enabled := FALSE;
	1848	end
	1849	else
	1850	btnNew.Enabled := FALSE;
	1851	end;
	1852
	1853	procedure TfrmTemplateEditor.tvTreeDragging(Sender: TObject;
	1854	Node: TTreeNode; var CanDrag: Boolean);
	1855
	1856	begin
	1857	CanDrag := (TTemplate(Node.Data).RealType in [ttDoc, ttGroup, ttClass]);
	1858	if(CanDrag) then
	1859	FDragNode := Node
	1860	else
	1861	FDragNode := nil;
	1862	end;
	1863
	1864	procedure TfrmTemplateEditor.tvTreeDragOver(Sender, Source: TObject; X,
	1865	Y: Integer; State: TDragState; var Accept: Boolean);
	1866	var
	1867	TmpNode: TTreeNode;
	1868	Tree: TTreeView;
	1869
	1870	begin
	1871	FDropNode := nil;
	1872	Accept := FALSE;
	1873	if(Source is TTreeView) and (assigned(FDragNode)) then
	1874	begin
	1875	Tree := TTreeView(Sender);
	1876	FDropNode := Tree.GetNodeAt(X,Y);
	1877	if(((Tree = tvShared) and (FCanEditShared)) or
	1878	((Tree = tvPersonal) and (FCanEditPersonal))) then
	1879	begin
	1880	if(assigned(FDropNode)) then
	1881	begin
	1882	FDropInto := (TTemplate(FDropNode.Data).RealType in AllTemplateFolderTypes);
	1883	if(FDropInto) then
	1884	TmpNode := FDropNode
	1885	else
	1886	TmpNode := FDropNode.Parent;
	1887	Accept := AllowMove(TmpNode, FDragNode);
	1888	end;
	1889	end;
	1890	end;
	1891	end;
	1892
	1893	procedure TfrmTemplateEditor.tvTreeDragDrop(Sender, Source: TObject; X,
	1894	Y: Integer);
	1895	var
	1896	Src, Template, Item: TTemplate;
	1897	SIdx, idx: integer;
	1898	TmpNode: TTreeNode;
	1899
	1900	begin
	1901	if(assigned(FDragNode)) and (assigned(FDropNode)) and (FDragNode <> FDropNode) then
	1902	begin
	1903	Item := TTemplate(FDragNode.Data);
	1904	if(FDropInto) then
	1905	begin
	1906	TmpNode := FDropNode;
	1907	idx := 0;
	1908	end
	1909	else
	1910	begin
	1911	TmpNode := FDropNode.Parent;
	1912	idx := TTemplate(FDropNode.Parent.Data).Items.IndexOf(FDropNode.Data);
	1913	end;
	1914	if(AllowMove(TmpNode, FDragNode) and (idx >= 0)) then
	1915	begin
	1916	Template := TTemplate(TmpNode.Data);
	1917	if(Template <> FDragNode.Parent.Data) and
	1918	(Template.Items.IndexOf(Item) >= 0) then
	1919	InfoBox(Template.PrintName + ' already contains the ' +
	1920	Item.PrintName + ' template.',
	1921	'Error', MB_OK or MB_ICONERROR)
	1922	else
	1923	begin
	1924	Src := TTemplate(FDragNode.Parent.Data);
	1925	Sidx := Src.Items.IndexOf(Item);
	1926	if CanClone(TmpNode) then
	1927	begin
	1928	if(Clone(TmpNode)) then
	1929	Template := TTemplate(TmpNode.Data);
	1930	if assigned(Template) and Template.CanModify then
	1931	begin
	1932	if(Sidx >= 0) and (FDragNode.TreeView = FDropNode.TreeView) and
	1933	(not FCopying) then // if same tree delete source
	1934	begin
	1935	if CanClone(FDragNode.Parent) then
	1936	begin
	1937	if(Clone(FDragNode.Parent)) then
	1938	Src := TTemplate(FDragNode.Parent.Data);
	1939	if assigned(Src) and Src.CanModify then
	1940	begin
	1941	Src.Items.Delete(Sidx);
	1942	if(Template = Src) then
	1943	Src := nil;
	1944	end
	1945	else
	1946	Src := nil;
	1947	end
	1948	else
	1949	Src := nil;
	1950	end
	1951	else
	1952	Src := nil;
	1953	if(idx > 0) then
	1954	idx := TTemplate(FDropNode.Parent.Data).Items.IndexOf(FDropNode.Data);
	1955	Template.Items.Insert(idx, Item);
	1956	if(TTreeView(FDropNode.TreeView) = tvShared) then
	1957	begin
	1958	Item.PersonalOwner := 0;
	1959	tvPersonal.Invalidate;
	1960	end;
	1961	TTreeView(FDragNode.TreeView).Selected := FDragNode;
	1962	TTreeView(FDragNode.TreeView).SetFocus;
	1963	Resync([Src, Template]);
	1964	btnApply.Enabled := TRUE;
	1965	end;
	1966	end;
	1967	end;
	1968	end;
	1969	end;
	1970	end;
	1971
	1972	procedure TfrmTemplateEditor.Resync(const Templates: array of TTemplate);
	1973	var
	1974	i, j: integer;
	1975	NodeList: TStringList;
	1976	TemplateList: TStringList;
	1977	Node: TTreeNode;
	1978	tmpl: TTemplate;
	1979	NodeID: string;
	1980
	1981	begin
	1982	NodeList := TStringList.Create;
	1983	try
	1984	TemplateList := TStringList.Create;
	1985	try
	1986	for i := low(Templates) to high(Templates) do
	1987	begin
	1988	tmpl := Templates[i];
	1989	if(assigned(tmpl)) then
	1990	begin
	1991	for j := 0 to tmpl.Nodes.Count-1 do
	1992	begin
	1993	Node := TTreeNode(tmpl.Nodes.Objects[j]);
	1994	if(NodeList.IndexOfObject(Node) < 0) then
	1995	begin
	1996	NodeID := IntToStr(Node.Level);
	1997	NodeID := copy('000',1,4-length(NodeID))+NodeID+U+tmpl.Nodes[j];
	1998	TemplateList.AddObject(NodeID,tmpl);
	1999	NodeList.AddObject(NodeId,Node);
	2000	end;
	2001	end;
	2002	end;
	2003	end;
	2004
	2005	{ By Sorting by Node Level, we prevent a Resync
	2006	of nodes deeper within the heirchary }
	2007
	2008	NodeList.Sort;
	2009
	2010	for i := 0 to NodeList.Count-1 do
	2011	begin
	2012	NodeID := NodeList[i];
	2013	Node := TTreeNode(NodeList.Objects[i]);
	2014	j := TemplateList.IndexOf(NodeID);
	2015	if(j >= 0) then
	2016	begin
	2017	tmpl := TTemplate(TemplateList.Objects[j]);
	2018	NodeID := Piece(NodeID,U,2);
	2019	if(tmpl.Nodes.IndexOf(NodeID) >= 0) then
	2020	begin
	2021	if(Node.TreeView = tvShared) then
	2022	dmodShared.Resync(Node, not cbShHide.Checked, FSharedEmptyNodeCount)
	2023	else
	2024	if(Node.TreeView = tvPersonal) then
	2025	dmodShared.Resync(Node, not cbPerHide.Checked, FPersonalEmptyNodeCount);
	2026	end;
	2027	end;
	2028	end;
	2029	finally
	2030	TemplateList.Free;
	2031	end;
	2032	finally
	2033	NodeList.Free;
	2034	end;
	2035	EnableNavControls;
	2036	if((assigned(FCurTree)) and (assigned(FCurTree.Selected))) then
	2037	tvTreeChange(FCurTree, FCurTree.Selected)
	2038	else
	2039	tvPersonal.Selected := tvPersonal.Items.GetFirstNode;
	2040	FCopyNode := nil;
	2041	end;
	2042
	2043	procedure TfrmTemplateEditor.sbCopyLeftClick(Sender: TObject);
	2044	begin
	2045	if(assigned(tvPersonal.Selected)) then
	2046	begin
	2047	if(not assigned(tvShared.Selected)) then
	2048	tvShared.Selected := tvShared.Items.GetFirstNode;
	2049	FDragNode := tvPersonal.Selected;
	2050	FDropNode := tvShared.Selected;
	2051	FDropInto := (TTemplate(FDropNode.Data).RealType in AllTemplateFolderTypes);
	2052	tvTreeDragDrop(tvPersonal, tvShared, 0,0);
	2053	end;
	2054	end;
	2055
	2056	procedure TfrmTemplateEditor.sbCopyRightClick(Sender: TObject);
	2057	begin
	2058	if(assigned(tvShared.Selected)) then
	2059	begin
	2060	if(not assigned(tvPersonal.Selected)) then
	2061	tvPersonal.Selected := tvPersonal.Items.GetFirstNode;
	2062	FDragNode := tvShared.Selected;
	2063	FDropNode := tvPersonal.Selected;
	2064	FDropInto := (TTemplate(FDropNode.Data).RealType in AllTemplateFolderTypes);
	2065	tvTreeDragDrop(tvShared, tvPersonal, 0,0);
	2066	end;
	2067	end;
	2068
[829]	2069	procedure TfrmTemplateEditor.AdjustControls4FontChange;
	2070	var
	2071	x: integer;
	2072
	2073	procedure Adjust(Control: TWinControl);
	2074	begin
	2075	x := x - Control.Width - 2;
	2076	Control.Left := x;
	2077	end;
	2078
	2079	begin
	2080	if FCanEditShared then
	2081	begin
	2082	x := pnlSharedBottom.Width;
	2083	Adjust(sbSHDelete);
	2084	Adjust(sbSHDown);
	2085	Adjust(sbSHUp);
	2086	cbSHHide.Width := x;
	2087	end;
	2088	x := pnlBottom.Width;
	2089	Adjust(btnApply);
	2090	Adjust(btnCancel);
	2091	Adjust(btnOK);
	2092	cbEditShared.Width := TextWidthByFont(cbEditShared.Font.Handle, cbEditShared.Caption) + 25;
	2093	cbNotes.Left := cbEditShared.Left + cbEditShared.Width + 60;
	2094	cbNotes.Width := TextWidthByFont(cbNotes.Font.Handle, cbNotes.Caption) + 25;
	2095	end;
	2096
[456]	2097	function TfrmTemplateEditor.AllowMove(ADropNode, ADragNode: TTreeNode): boolean;
	2098	var
	2099	i: integer;
	2100	TmpNode: TTreeNode;
	2101	DragTemplate, DropTemplate: TTemplate;
	2102
	2103	begin
	2104	if(assigned(ADropNode) and assigned(ADragNode)) then
	2105	begin
	2106	DropTemplate := TTemplate(ADropNode.Data);
	2107	DragTemplate := TTemplate(ADragNode.Data);
	2108	if IsTemplateLocked(ADropNode) then
	2109	Result := FALSE
	2110	else
	2111	Result := (DragTemplate.RealType in [ttDoc, ttGroup, ttClass]);
	2112	if(Result) then
	2113	begin
	2114	if(FCopying) then
	2115	begin
	2116	if(DropTemplate.Items.IndexOf(DragTemplate) >= 0) then
	2117	Result := FALSE;
	2118	end
	2119	else
	2120	if((assigned(ADragNode.Parent)) and (ADropNode <> ADragNode.Parent) and
	2121	(DropTemplate.Items.IndexOf(DragTemplate) >= 0)) then
	2122	Result := FALSE;
	2123	end;
	2124	if(Result) then
	2125	begin
	2126	for i := 0 to DropTemplate.Nodes.Count-1 do
	2127	begin
	2128	TmpNode := TTreeNode(DropTemplate.Nodes.Objects[i]);
	2129	while (Result and (assigned(TmpNode.Parent))) do
	2130	begin
	2131	if(TmpNode.Data = DragTemplate) then
	2132	Result := FALSE
	2133	else
	2134	TmpNode := TmpNode.Parent;
	2135	end;
	2136	if(not Result) then break;
	2137	end;
	2138	end;
	2139	end
	2140	else
	2141	Result := FALSE;
	2142	end;
	2143
	2144	function TfrmTemplateEditor.Clone(Node: TTreeNode): boolean;
	2145	var
	2146	idx: integer;
	2147	Prnt, OldT, NewT: TTemplate;
	2148	PNode: TTreeNode;
	2149	ok: boolean;
	2150
	2151	begin
	2152	Result := FALSE;
	2153	if((assigned(Node)) and (TTreeView(Node.TreeView) = tvPersonal)) then
	2154	begin
	2155	OldT := TTemplate(Node.Data);
	2156	if(OldT.PersonalOwner <> User.DUZ) then
	2157	begin
	2158	PNode := Node.Parent;
	2159	Prnt := nil;
	2160	if (assigned(PNode)) then
	2161	begin
	2162	ok := CanClone(PNode);
	2163	if ok then
	2164	begin
	2165	Clone(PNode);
	2166	Prnt := TTemplate(PNode.Data);
	2167	ok := Prnt.CanModify;
	2168	end;
	2169	end
	2170	else
	2171	ok := TRUE;
	2172	if ok then
	2173	begin
	2174	BtnApply.Enabled := TRUE;
	2175	Result := TRUE;
	2176	NewT := OldT.Clone(User.DUZ);
	2177	OldT.RemoveNode(Node);
	2178	MarkDeleted(OldT);
	2179	Node.Data := NewT;
	2180	NewT.AddNode(Node);
	2181	if(assigned(Prnt)) then
	2182	begin
	2183	idx := Prnt.Items.IndexOf(OldT);
	2184	if(idx >= 0) then
	2185	Prnt.Items[idx] := NewT;
	2186	end;
	2187	tvPersonal.Invalidate;
	2188	ShowTemplateType(NewT);
	2189	end;
	2190	end;
	2191	end;
	2192	end;
	2193
	2194	procedure TfrmTemplateEditor.reBoilChange(Sender: TObject);
	2195	var
	2196	DoInfo, DoRefresh: boolean;
	2197	TmpBPlate: string;
	2198	Template: TTemplate;
	2199	x: integer;
	2200
	2201	begin
	2202	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected))) then
	2203	begin
	2204	Template := TTemplate(FCurTree.Selected.Data);
	2205	TmpBPlate := reBoil.Lines.Text;
	2206	if(Template.Boilerplate <> TmpBPlate) then
	2207	begin
	2208	if CanClone(FCurTree.Selected) then
	2209	begin
	2210	DoRefresh := Clone(FCurTree.Selected);
	2211	if(DoRefresh) then
	2212	Template := TTemplate(FCurTree.Selected.Data);
	2213	if assigned(Template) and Template.CanModify then
	2214	begin
	2215	DoInfo := FALSE;
	2216	if(Template.Boilerplate = '') or (TmpBPlate = '') then
	2217	DoInfo := TRUE;
	2218	Template.Boilerplate := TmpBPlate;
	2219	TTemplate(FCurTree.Selected.Data).Gap := StrToIntDef(edtGap.Text, 0);
	2220	if(Template.RealType = ttGroup) then
	2221	begin
	2222	reGroupBP.Text := Template.FullBoilerplate;
	2223	end;
	2224	if(DoRefresh) then
	2225	begin
	2226	tvShared.Invalidate;
	2227	tvPersonal.Invalidate;
	2228	end;
	2229	if(DoInfo) then
	2230	begin
	2231	x := reBoil.SelStart;
	2232	ShowInfo(FCurTree.Selected);
	2233	reBoil.SelStart := x;
	2234	end;
	2235	end;
	2236	end;
	2237	btnApply.Enabled := TRUE;
	2238	// reBoil.Lines.Text := Template.Boilerplate;
	2239	end;
	2240	end;
	2241	end;
	2242
	2243	procedure TfrmTemplateEditor.SharedEditing;
	2244	begin
	2245	{$IFDEF OwnerScan}
	2246	lblPerOwner.Visible := FCanEditShared;
	2247	cboOwner.Visible := FCanEditShared;
	2248	{$ELSE}
	2249	lblPerOwner.Visible := FALSE;
	2250	cboOwner.Visible := FALSE;
	2251	{$ENDIF}
	2252	sbCopyLeft.Visible := FCanEditShared;
	2253	if(not FCanEditShared) then
	2254	cbShHide.Checked := TRUE;
	2255	cbShHide.Visible := FCanEditShared;
	2256	sbShDelete.Visible := FCanEditShared;
	2257	sbShUp.Visible := FCanEditShared;
	2258	sbShDown.Visible := FCanEditShared;
	2259	tvShared.ReadOnly := not FCanEditShared;
	2260	MoveCopyButtons;
	2261	tvTreeChange(FCurTree, FCurTree.Selected);
[829]	2262	if FCanEditShared then
	2263	AdjustControls4FontChange;
[456]	2264	end;
	2265
	2266	procedure TfrmTemplateEditor.cbEditSharedClick(Sender: TObject);
	2267	begin
	2268	FCanEditShared := cbEditShared.Checked;
	2269	SharedEditing;
	2270	end;
	2271
	2272	procedure TfrmTemplateEditor.popTemplatesPopup(Sender: TObject);
	2273	var
	2274	Tree: TTreeView;
	2275	Node: TTreeNode;
	2276	FindOn: boolean;
	2277	Txt: string;
	2278
	2279	begin
	2280	FFromMainMenu := FALSE;
	2281	Tree := GetTree;
	2282	Node := Tree.Selected;
	2283	Tree.Selected := Node; // This line prevents selected from changing after menu closes
	2284	mnuCollapseTree.Enabled := dmodShared.NeedsCollapsing(Tree);
	2285	if(Tree = tvShared) then
	2286	begin
	2287	Txt := 'Shared';
	2288	FindOn := FFindShOn;
	2289	mnuNodeDelete.Enabled := ((sbShDelete.Visible) and (sbShDelete.Enabled));
	2290	end
	2291	else
	2292	begin
	2293	Txt := 'Personal';
	2294	FindOn := FFindPerOn;
	2295	mnuNodeDelete.Enabled := ((sbPerDelete.Visible) and (sbPerDelete.Enabled));
	2296	end;
	2297	mnuFindTemplates.Checked := FindOn;
	2298	mnuCollapseTree.Caption := 'Collapse '+Txt+' &Tree';
	2299	mnuFindTemplates.Caption := '&Find '+Txt+' Templates';
	2300
	2301	if(assigned(Tree) and assigned(Tree.Selected) and assigned(Tree.Selected.Data)) then
	2302	begin
	2303	mnuNodeCopy.Enabled := (TTemplate(Tree.Selected.Data).RealType in [ttDoc, ttGroup, ttClass]);
	2304	mnuNodeSort.Enabled := (TTemplate(Tree.Selected.Data).RealType in AllTemplateFolderTypes) and
	2305	(Tree.Selected.HasChildren) and
	2306	(Tree.Selected.GetFirstChild.GetNextSibling <> nil);
	2307	end
	2308	else
	2309	begin
	2310	mnuNodeCopy.Enabled := FALSE;
	2311	mnuNodeSort.Enabled := FALSE;
	2312	end;
	2313	FPasteNode := Tree.Selected;
	2314	mnuNodePaste.Enabled := PasteOK;
	2315	mnuNodeNew.Enabled := btnNew.Enabled;
	2316	mnuNodeAutoGen.Enabled := btnNew.Enabled;
	2317	end;
	2318
	2319	procedure TfrmTemplateEditor.mnuCollapseTreeClick(Sender: TObject);
	2320	begin
	2321	if(GetTree = tvShared) then
	2322	begin
	2323	tvShared.Selected := tvShared.Items.GetFirstNode;
	2324	tvShared.FullCollapse;
	2325	end
	2326	else
	2327	begin
	2328	tvPersonal.Selected := tvShared.Items.GetFirstNode;
	2329	tvPersonal.FullCollapse;
	2330	end;
	2331	end;
	2332
	2333	procedure TfrmTemplateEditor.mnuFindTemplatesClick(Sender: TObject);
	2334	var
	2335	Tree: TTreeView;
	2336
	2337	begin
	2338	Tree := GetTree;
	2339	if(Tree = tvShared) then
	2340	begin
	2341	FFindShOn := not FFindShOn;
	2342	pnlShSearch.Visible := FFindShOn;
	2343	if(FFindShOn) then
	2344	begin
	2345	edtShSearch.SetFocus;
	2346	btnShFind.Enabled := (edtShSearch.Text <> '');
	2347	end;
	2348	end
	2349	else
	2350	begin
	2351	FFindPerOn := not FFindPerOn;
	2352	pnlPerSearch.Visible := FFindPerOn;
	2353	if(FFindPerOn) then
	2354	begin
	2355	edtPerSearch.SetFocus;
	2356	btnPerFind.Enabled := (edtPerSearch.Text <> '');
	2357	end;
	2358	end;
	2359	SetFindNext(Tree, FALSE);
	2360	end;
	2361
	2362	procedure TfrmTemplateEditor.ShowTemplateType(Template: TTemplate);
	2363	begin
	2364	if(Template.PersonalOwner > 0) then
	2365	gbProperties.Caption := 'Personal'
	2366	else
	2367	gbProperties.Caption := 'Shared';
	2368	gbProperties.Caption := gbProperties.Caption + PropText;
	2369	end;
	2370
	2371	function TfrmTemplateEditor.GetTree: TTreeView;
	2372	begin
	2373	if(FFromMainMenu) then
	2374	Result := FMainMenuTree
	2375	else
	2376	begin
	2377	if(TTemplateTreeType(PopupComponent(popTemplates, popTemplates).Tag) = ttShared) then
	2378	Result := tvShared
	2379	else
	2380	Result := tvPersonal;
	2381	end;
	2382	end;
	2383
	2384	procedure TfrmTemplateEditor.btnFindClick(Sender: TObject);
	2385	var
[829]	2386	Found: TTreeNode;
[456]	2387	edtSearch: TEdit;
[829]	2388	IsNext: boolean;
[456]	2389	FindNext: boolean;
	2390	FindWholeWords: boolean;
	2391	FindCase: boolean;
	2392	Tree: TTreeView;
	2393	LastFoundNode, TmpNode: TTreeNode;
[829]	2394	// S1,S2: string;
[456]	2395
	2396	begin
	2397	if(TTemplateTreeType(TButton(Sender).Tag) = ttShared) then
	2398	begin
	2399	Tree := tvShared;
	2400	edtSearch := edtShSearch;
	2401	FindNext := FFindShNext;
	2402	FindWholeWords := cbShWholeWords.Checked;
	2403	FindCase := cbShMatchCase.Checked;
	2404	LastFoundNode := FLastFoundShNode;
	2405	end
	2406	else
	2407	begin
	2408	Tree := tvPersonal;
	2409	edtSearch := edtPerSearch;
	2410	FindNext := FFindPerNext;
	2411	FindWholeWords := cbPerWholeWords.Checked;
	2412	FindCase := cbPerMatchCase.Checked;
	2413	LastFoundNode := FLastFoundPerNode;
	2414	end;
	2415	if(edtSearch.text <> '') then
	2416	begin
[829]	2417	IsNext := ((FindNext) and assigned (LastFoundNode));
	2418	if IsNext then
	2419
	2420	TmpNode := LastFoundNode
[456]	2421	else
	2422	TmpNode := Tree.Items.GetFirstNode;
[829]	2423	FInternalHiddenExpand := TRUE;
	2424	try
	2425	Found := FindTemplate(edtSearch.Text, Tree, Self, TmpNode,
	2426	IsNext, not FindCase, FindWholeWords);
	2427	finally
	2428	FInternalHiddenExpand := FALSE;
[456]	2429	end;
[829]	2430	if Assigned(Found) then
[456]	2431	begin
[829]	2432	Tree.Selected := Found;
[456]	2433	if(Tree = tvShared) then
[829]	2434	FLastFoundShNode := Found
[456]	2435	else
[829]	2436	FLastFoundPerNode := Found;
[456]	2437	SetFindNext(Tree, TRUE);
	2438	end;
	2439	end;
	2440	edtSearch.SetFocus;
	2441	end;
	2442
	2443	procedure TfrmTemplateEditor.edtSearchChange(Sender: TObject);
	2444	begin
	2445	if(TTemplateTreeType(TEdit(Sender).Tag) = ttShared) then
	2446	begin
	2447	btnShFind.Enabled := (edtShSearch.Text <> '');
	2448	SetFindNext(tvShared, FALSE);
	2449	end
	2450	else
	2451	begin
	2452	btnPerFind.Enabled := (edtPerSearch.Text <> '');
	2453	SetFindNext(tvPersonal, FALSE);
	2454	end;
	2455	end;
	2456
	2457	procedure TfrmTemplateEditor.SetFindNext(const Tree: TTreeView; const Value: boolean);
	2458	begin
	2459	if(Tree = tvShared) then
	2460	begin
	2461	if(FFindShNext <> Value) then
	2462	begin
	2463	FFindShNext := Value;
	2464	if(FFindShNext) then btnShFind.Caption := 'Find Next'
	2465	else btnShFind.Caption := 'Find';
	2466	end;
	2467	end
	2468	else
	2469	begin
	2470	if(FFindPerNext <> Value) then
	2471	begin
	2472	FFindPerNext := Value;
	2473	if(FFindPerNext) then btnPerFind.Caption := 'Find Next'
	2474	else btnPerFind.Caption := 'Find';
	2475	end;
	2476	end;
	2477	end;
	2478
	2479	procedure TfrmTemplateEditor.edtShSearchEnter(Sender: TObject);
	2480	begin
	2481	btnShFind.Default := TRUE;
	2482	end;
	2483
	2484	procedure TfrmTemplateEditor.edtShSearchExit(Sender: TObject);
	2485	begin
	2486	btnShFind.Default := FALSE;
	2487	end;
	2488
	2489	procedure TfrmTemplateEditor.edtPerSearchEnter(Sender: TObject);
	2490	begin
	2491	btnPerFind.Default := TRUE;
	2492	end;
	2493
	2494	procedure TfrmTemplateEditor.edtPerSearchExit(Sender: TObject);
	2495	begin
	2496	btnPerFind.Default := FALSE;
	2497	end;
	2498
	2499	procedure TfrmTemplateEditor.btnOKClick(Sender: TObject);
	2500	begin
	2501	if(ScanNames) then
	2502	begin
	2503	if(SaveAllTemplates) then
	2504	begin
	2505	FOK2Close := TRUE;
	2506	ModalResult := mrOK;
	2507	end
	2508	else
	2509	BtnApply.Enabled := BackupDiffers;
	2510	end;
	2511	end;
	2512
	2513	procedure TfrmTemplateEditor.FormShow(Sender: TObject);
	2514	begin
	2515	if(FFirstShow) then
	2516	begin
	2517	FUpdating := FALSE;
	2518	FFirstShow := FALSE;
	2519	if(FFocusName) then
	2520	begin
	2521	edtName.SetFocus;
	2522	edtName.SelectAll;
	2523	end;
	2524	pnlBoilerplateResize(Self);
[829]	2525	AdjustControls4FontChange;
	2526	MoveCopyButtons;
[456]	2527	end;
	2528	end;
	2529
	2530	procedure TfrmTemplateEditor.mnuBPInsertObjectClick(Sender: TObject);
	2531	var
	2532	i: integer;
	2533	DoIt: boolean;
	2534
	2535	begin
	2536	if(not assigned(frmTemplateObjects)) then
	2537	begin
	2538	dmodShared.LoadTIUObjects;
	2539	frmTemplateObjects := TfrmTemplateObjects.Create(Self);
	2540	DoIt := TRUE;
	2541	if (UserTemplateAccessLevel <> taEditor) then
	2542	begin
	2543	UpdatePersonalObjects;
[829]	2544	if uPersonalObjects.Count > 0 then // -------- CQ #8665 - RV ------------
[456]	2545	begin
	2546	DoIt := FALSE;
	2547	for i := 0 to dmodShared.TIUObjects.Count-1 do
[829]	2548	if uPersonalObjects.IndexOf(Piece(dmodShared.TIUObjects[i],U,2)) >= 0 then // -------- CQ #8665 - RV ------------
[456]	2549	frmTemplateObjects.cboObjects.Items.Add(dmodShared.TIUObjects[i]);
	2550	end;
	2551	end;
	2552	if DoIt then
[829]	2553	FastAssign(dmodShared.TIUObjects, frmTemplateObjects.cboObjects.Items);
[456]	2554	frmTemplateObjects.Font := Font;
	2555	frmTemplateObjects.re := reBoil;
	2556	frmTemplateObjects.AutoLongLines := AutoLongLines;
	2557	end;
	2558	frmTemplateObjects.Show;
	2559	end;
	2560
	2561	procedure TfrmTemplateEditor.mnuBPErrorCheckClick(Sender: TObject);
	2562	begin
	2563	FBPOK := FALSE;
	2564	if(reBoil.Lines.Count > 0) then
	2565	begin
	2566	if(dmodShared.TemplateOK(FCurTree.Selected.Data,'OK')) then
	2567	begin
	2568	TestBoilerplate(reBoil.Lines);
	2569	if(RPCBrokerV.Results.Count > 0) then
	2570	InfoBox('Boilerplate Contains Errors:'+CRLF+CRLF+
	2571	RPCBrokerV.Results.Text, 'Error', MB_OK or MB_ICONERROR)
	2572	else
	2573	begin
	2574	FBPOK := TRUE;
	2575	if(assigned(Sender)) then
	2576	InfoBox('No Errors Found in Boilerplate.', 'Information', MB_OK or MB_ICONINFORMATION);
	2577	end;
	2578	end;
	2579	end;
	2580	end;
	2581
	2582	procedure TfrmTemplateEditor.popBoilerplatePopup(Sender: TObject);
	2583	var
	2584	tryOK, ok: boolean;
	2585
	2586	begin
	2587	ok := not reBoil.ReadOnly;
	2588	mnuBPInsertObject.Enabled := ok;
	2589	mnuBPInsertField.Enabled := ok;
	2590
	2591	mnuBPPaste.Enabled := (ok and Clipboard.HasFormat(CF_TEXT));
	2592	if(ok) then
	2593	ok := (reBoil.Lines.Count > 0);
	2594	tryOK := (reBoil.Lines.Count > 0) or ((pnlGroupBP.Visible) and (reGroupBP.Lines.Count > 0));
	2595	mnuBPErrorCheck.Enabled := tryOK;
	2596	mnuBPTry.Enabled := tryOK;
	2597	mnuBPSpellCheck.Enabled := ok and SpellCheckAvailable;
	2598	mnuBPCheckGrammar.Enabled := ok and SpellCheckAvailable;
	2599
	2600	mnuBPCopy.Enabled := (reBoil.SelLength > 0);
	2601	mnuBPCut.Enabled := (ok and (reBoil.SelLength > 0));
	2602	mnuBPSelectAll.Enabled := (reBoil.Lines.Count > 0);
	2603	mnuBPUndo.Enabled := (reBoil.Perform(EM_CANUNDO, 0, 0) <> 0);
	2604	end;
	2605
	2606	function TfrmTemplateEditor.ScanNames: boolean;
	2607	var
	2608	Errors: TList;
	2609	msg: string;
	2610	i: integer;
	2611	Node: TTreeNode;
	2612
	2613	procedure ScanTree(Tree: TTreeView);
	2614	begin
	2615	Node := Tree.Items.GetFirstNode;
	2616	while (assigned(Node)) do
	2617	begin
	2618	if(Node.Text <> EmptyNodeText) and (assigned(Node.Data)) then
	2619	begin
	2620	if(BadTemplateName(Node.Text)) then
	2621	Errors.Add(Node);
	2622	end;
	2623	Node := Node.GetNext;
	2624	end;
	2625	end;
	2626
	2627	begin
	2628	Errors := TList.Create;
	2629	try
	2630	ScanTree(tvShared);
	2631	ScanTree(tvPersonal);
	2632	if(Errors.Count > 0) then
	2633	begin
	2634	if(Errors.Count > 1) then
	2635	msg := IntToStr(Errors.Count) + ' Templates have invalid names'
	2636	else
	2637	msg := 'Template has an invalid name';
	2638	msg := msg + ': ';
	2639	for i := 0 to Errors.Count-1 do
	2640	begin
	2641	if(i > 0) then msg := msg + ', ';
	2642	Node := TTreeNode(Errors[i]);
	2643	msg := msg + Node.Text;
	2644	Node.MakeVisible;
	2645	end;
	2646	msg := msg + '.' + BadNameText;
	2647	InfoBox(msg, 'Error', MB_OK or MB_ICONERROR);
	2648	TTreeView(Node.TreeView).Selected := TTreeNode(Errors[0]);
	2649	end;
	2650	finally
	2651	Result := (Errors.Count = 0);
	2652	Errors.Free;
	2653	end;
	2654	end;
	2655
	2656	procedure TfrmTemplateEditor.btnCancelClick(Sender: TObject);
	2657	begin
	2658	FOK2Close := TRUE;
	2659	end;
	2660
[829]	2661	procedure TfrmTemplateEditor.FormClose(Sender: TObject;
	2662	var Action: TCloseAction);
	2663	begin
	2664	SaveUserBounds(Self);
	2665	end;
	2666
[456]	2667	procedure TfrmTemplateEditor.FormCloseQuery(Sender: TObject;
	2668	var CanClose: Boolean);
	2669	var
	2670	ans: word;
	2671
	2672	begin
	2673	if(not FOK2Close) and (BackupDiffers) then
	2674	begin
	2675	ans := InfoBox('Save Changes?', 'Confirmation', MB_YESNOCANCEL or MB_ICONQUESTION);
	2676	if(ans = IDCANCEL) then
	2677	CanClose := FALSE
	2678	else
	2679	if(ans = IDYES) then
	2680	begin
	2681	CanClose := FALSE;
	2682	if(ScanNames) then
	2683	begin
	2684	if(SaveAllTemplates) then
	2685	CanClose := TRUE
	2686	else
	2687	BtnApply.Enabled := BackupDiffers;
	2688	end;
	2689	end;
	2690	end;
	2691	end;
	2692
	2693	procedure TfrmTemplateEditor.mnuBPSpellCheckClick(Sender: TObject);
	2694	begin
	2695	SpellCheckForControl(reBoil);
	2696	end;
	2697
	2698	procedure TfrmTemplateEditor.splBoilMoved(Sender: TObject);
	2699	begin
[829]	2700	if pnlBoilerplate.Visible and pnlGroupBP.Visible then
	2701	tmplEditorSplitterBoil := reBoil.Height;
	2702	if pnlNotes.Visible then
	2703	tmplEditorSplitterNotes := pnlNotes.Height;
[456]	2704	pnlBoilerplateResize(Self);
	2705	end;
	2706
	2707	procedure TfrmTemplateEditor.edtGapKeyPress(Sender: TObject;
	2708	var Key: Char);
	2709	begin
	2710	if(not (Key in ['0','1','2','3'])) then Key := #0;
	2711	end;
	2712
	2713	procedure TfrmTemplateEditor.edtNameExit(Sender: TObject);
	2714	var
	2715	Warn: boolean;
	2716
	2717	begin
	2718	Warn := (ActiveControl <> btnCancel) and (BadTemplateName(edtName.Text));
	2719	if(Warn and ((ActiveControl = sbShDelete) or (ActiveControl = sbPerDelete))) then
	2720	begin
	2721	if((assigned(FCurTree)) and (assigned(FCurTree.Selected))) then
	2722	Warn := not AutoDel(TTemplate(FCurTree.Selected.Data));
	2723	end;
	2724	if(Warn) then
	2725	begin
	2726	InfoBox('Template has an invalid name: ' + edtName.Text + '.' + BadNameText, 'Error', MB_OK or MB_ICONERROR);
	2727	edtName.SetFocus;
	2728	end;
	2729	end;
	2730
	2731	procedure TfrmTemplateEditor.tmrAutoScrollTimer(Sender: TObject);
	2732	const
	2733	EdgeScroll = 16;
	2734
	2735	var
	2736	TopNode: TTreeNode;
	2737	Redraw: boolean;
	2738	TmpPt: TPoint;
	2739	ht: THitTests;
	2740	HPos, RMax: integer;
	2741
	2742	begin
	2743	if(assigned(FDropNode)) then
	2744	begin
	2745	TopNode := FDropNode.TreeView.TopItem;
	2746	Redraw := FALSE;
	2747	TmpPt := FDropNode.TreeView.ScreenToClient(Mouse.CursorPos);
	2748	if(TopNode = FDropNode) and (TopNode <> TTreeView(FDropNode.TreeView).Items.GetFirstNode) then
	2749	begin
	2750	FDropNode.TreeView.TopItem := TopNode.GetPrevVisible;
	2751	Redraw := TRUE;
	2752	end
	2753	else
	2754	begin
	2755	RMax := FDropNode.TreeView.ClientHeight - EdgeScroll;
	2756	if((TmpPt.Y > RMax) and (FDropNode.GetNextVisible <> nil)) then
	2757	begin
	2758	TORTreeView(FDropNode.TreeView).VertScrollPos :=
	2759	TORTreeView(FDropNode.TreeView).VertScrollPos + 1;
	2760	Redraw := TRUE;
	2761	end;
	2762	end;
	2763	if(FLastDropNode <> FDropNode) then
	2764	begin
	2765	if((assigned(FDropNode)) and (FDropNode.GetNext = nil)) then
	2766	Redraw := TRUE
	2767	else
	2768	if((assigned(FLastDropNode)) and (FLastDropNode.GetNext = nil)) then
	2769	Redraw := TRUE;
	2770	FLastDropNode := FDropNode;
	2771	FDragOverCount := 0;
	2772	end
	2773	else
	2774	begin
	2775	if(FDropNode.HasChildren) and (not FDropNode.Expanded) then
	2776	begin
	2777	ht := FDropNode.TreeView.GetHitTestInfoAt(TmpPt.X, TmpPt.Y);
	2778	if(htOnButton in ht) then
	2779	begin
	2780	inc(FDragOverCount);
	2781	if(FDragOverCount > 4) then
	2782	begin
	2783	TopNode := FDropNode.TreeView.TopItem;
	2784	FDropNode.Expand(FALSE);
	2785	FDropNode.TreeView.TopItem := TopNode;
	2786	FDragOverCount := 0;
	2787	Redraw := TRUE;
	2788	end;
	2789	end
	2790	else
	2791	FDragOverCount := 0;
	2792	end;
	2793	if(not Redraw) then
	2794	begin
	2795	HPos := TORTreeView(FDropNode.TreeView).HorzScrollPos;
	2796	if(HPos > 0) and (TmpPt.X < EdgeScroll) then
	2797	begin
	2798	TORTreeView(FDropNode.TreeView).HorzScrollPos :=
	2799	TORTreeView(FDropNode.TreeView).HorzScrollPos - EdgeScroll;
	2800	Redraw := TRUE;
	2801	end
	2802	else
	2803	begin
	2804	RMax := FDropNode.TreeView.ClientWidth - EdgeScroll;
	2805	if(TmpPt.X > RMax) then
	2806	begin
	2807	TORTreeView(FDropNode.TreeView).HorzScrollPos :=
	2808	TORTreeView(FDropNode.TreeView).HorzScrollPos + EdgeScroll;
	2809	Redraw := TRUE;
	2810	end;
	2811	end;
	2812	end;
	2813	end;
	2814	if(Redraw) then
	2815	begin
	2816	TmpPt := Mouse.CursorPos; // Wiggling the mouse causes needed windows messages to fire
	2817	inc(TmpPt.X);
	2818	Mouse.CursorPos := TmpPt;
	2819	dec(TmpPt.X);
	2820	Mouse.CursorPos := TmpPt;
	2821	FDropNode.TreeView.Invalidate;
	2822	end;
	2823	end;
	2824	end;
	2825
	2826	procedure TfrmTemplateEditor.tvTreeStartDrag(Sender: TObject;
	2827	var DragObject: TDragObject);
	2828	begin
	2829	FDropNode := nil;
	2830	FLastDropNode := nil;
	2831	FDragOverCount := 0;
	2832	tmrAutoScroll.Enabled := TRUE;
	2833	end;
	2834
	2835	procedure TfrmTemplateEditor.tvTreeEndDrag(Sender, Target: TObject; X,
	2836	Y: Integer);
	2837	begin
	2838	tmrAutoScroll.Enabled := FALSE;
	2839	end;
	2840
	2841	procedure TfrmTemplateEditor.mnuGroupBPCopyClick(Sender: TObject);
	2842	begin
	2843	reGroupBP.CopyToClipboard;
	2844	end;
	2845
	2846	procedure TfrmTemplateEditor.popGroupPopup(Sender: TObject);
	2847	begin
	2848	mnuGroupBPCopy.Enabled := (pnlGroupBP.Visible and (reGroupBP.SelLength > 0));
	2849	mnuGroupBPSelectAll.Enabled := (pnlGroupBP.Visible and (reGroupBP.Lines.Count > 0));
	2850	end;
	2851
	2852	procedure TfrmTemplateEditor.mnuBPCutClick(Sender: TObject);
	2853	begin
	2854	reBoil.CutToClipboard;
	2855	end;
	2856
	2857	procedure TfrmTemplateEditor.mnuBPCopyClick(Sender: TObject);
	2858	begin
	2859	reBoil.CopyToClipboard;
	2860	end;
	2861
	2862	procedure TfrmTemplateEditor.mnuBPPasteClick(Sender: TObject);
	2863	begin
	2864	reBoil.SelText := Clipboard.AsText;
	2865	end;
	2866
	2867	procedure TfrmTemplateEditor.mnuGroupBPSelectAllClick(Sender: TObject);
	2868	begin
	2869	reGroupBP.SelectAll;
	2870	end;
	2871
	2872	procedure TfrmTemplateEditor.mnuBPSelectAllClick(Sender: TObject);
	2873	begin
	2874	reBoil.SelectAll;
	2875	end;
	2876
	2877	procedure TfrmTemplateEditor.mnuNodeDeleteClick(Sender: TObject);
	2878	begin
	2879	if(FCurTree = tvShared) and (sbShDelete.Visible) and (sbShDelete.Enabled) then
	2880	sbDeleteClick(sbShDelete)
	2881	else
	2882	if(FCurTree = tvPersonal) and (sbPerDelete.Visible) and (sbPerDelete.Enabled) then
	2883	sbDeleteClick(sbPerDelete);
	2884	end;
	2885
	2886	procedure TfrmTemplateEditor.mnuNodeCopyClick(Sender: TObject);
	2887	begin
	2888	if(assigned(FCurTree)) then
	2889	FCopyNode := FCurTree.Selected
	2890	else
	2891	FCopyNode := nil;
	2892	end;
	2893
	2894	procedure TfrmTemplateEditor.mnuNodePasteClick(Sender: TObject);
	2895	begin
	2896	if(PasteOK) then
	2897	begin
	2898	FDragNode := FCopyNode;
	2899	FDropNode := FPasteNode;
	2900	FDropInto := (TTemplate(FDropNode.Data).RealType in AllTemplateFolderTypes);
	2901	FCopying := TRUE;
	2902	try
	2903	tvTreeDragDrop(tvShared, tvPersonal, 0, 0);
	2904	finally
	2905	FCopying := FALSE;
	2906	end;
	2907	end;
	2908	FCopyNode := nil;
	2909	end;
	2910
	2911	function TfrmTemplateEditor.PasteOK: boolean;
	2912	var
	2913	OldCopying: boolean;
	2914	Node: TTreeNode;
	2915
	2916	begin
	2917	Result := assigned(FCopyNode) and assigned(FPasteNode);
	2918	if(Result) then
	2919	Result := (FTreeControl[TTemplateTreeType(FPasteNode.TreeView.Tag), tcDel].Visible);
	2920	if(Result) then
	2921	begin
	2922	OldCopying := FCopying;
	2923	FCopying := TRUE;
	2924	try
	2925	Node := FPasteNode;
	2926	if(TTemplate(Node.Data).RealType = ttDoc) then
	2927	Node := Node.Parent;
	2928	Result := AllowMove(Node, FCopyNode);
	2929	finally
	2930	FCopying := OldCopying;
	2931	end;
	2932	end;
	2933	end;
	2934
	2935	procedure TfrmTemplateEditor.mnuBPUndoClick(Sender: TObject);
	2936	begin
	2937	reBoil.Perform(EM_UNDO, 0, 0);
	2938	end;
	2939
	2940	procedure TfrmTemplateEditor.tvTreeKeyDown(Sender: TObject;
	2941	var Key: Word; Shift: TShiftState);
	2942	begin
	2943
	2944	if(Key = VK_DELETE) then
	2945	begin
	2946	if(Sender = tvShared) then
	2947	begin
	2948	if(sbShDelete.Visible and sbShDelete.Enabled) then
	2949	sbDeleteClick(sbShDelete);
	2950	end
	2951	else
	2952	begin
	2953	if(sbPerDelete.Visible and sbPerDelete.Enabled) then
	2954	sbDeleteClick(sbPerDelete);
	2955	end;
	2956	end;
	2957	//Code Added to provide CTRL Key access for 508 compliance GRE 3/03
	2958	if (ssCtrl in Shift) and (Key = VK_A) then
	2959	reBoil.SelectAll
	2960	else
	2961	if (ssCtrl in Shift) and (Key = VK_C) then
	2962	reBoil.CopyToClipboard
	2963	else
	2964	if (ssCtrl in Shift) and (Key = VK_E) then
	2965	mnuBPErrorCheckClick(Self)
	2966	else
	2967	if (ssCtrl in Shift) and (Key = VK_F) then
	2968	mnuBPInsertFieldClick(Self)
	2969	else
	2970	if (ssCtrl in Shift) and (Key = VK_G) then
	2971	GrammarCheckForControl(reBoil)
	2972	else
	2973	if (ssCtrl in Shift) and (Key = VK_I) then
	2974	mnuBPInsertObjectClick(Self)
	2975	else
	2976	if (ssCtrl in Shift) and (Key = VK_S) then
	2977	SpellCheckForControl(reBoil)
	2978	else
	2979	if (ssCtrl in Shift) and (Key = VK_T) then
	2980	mnuBPTryClick(Self)
	2981	else
	2982	if (ssCtrl in Shift) and (Key = VK_V) then
	2983	reBoil.SelText := Clipboard.AsText
	2984	else
	2985	if (ssCtrl in Shift) and (Key = VK_X) then
	2986	reBoil.CutToClipboard
	2987	else
	2988	if (ssCtrl in Shift) and (Key = VK_Z) then
	2989	reBoil.Perform(EM_UNDO, 0, 0);
	2990	//End of ---- Code Added to provide CTRL Key access for 508 compliance GRE 3/03
	2991	end;
	2992
	2993	procedure TfrmTemplateEditor.mnuEditClick(Sender: TObject);
	2994	var
	2995	tryOK, ok: boolean;
	2996
	2997	begin
	2998	if pnlBoilerplate.Visible then
	2999	begin
	3000	ok := (not reBoil.ReadOnly);
	3001	mnuInsertObject.Enabled := ok;
	3002	mnuInsertField.Enabled := ok;
	3003	mnuPaste.Enabled := (ok and Clipboard.HasFormat(CF_TEXT));
	3004	if(ok) then
	3005	ok := (reBoil.Lines.Count > 0);
	3006	tryOK := (reBoil.Lines.Count > 0) or ((pnlGroupBP.Visible) and (reGroupBP.Lines.Count > 0));
	3007	mnuErrorCheck.Enabled := tryOK;
	3008	mnuTry.Enabled := tryOK;
	3009	mnuSpellCheck.Enabled := ok and SpellCheckAvailable;
	3010	mnuCheckGrammar.Enabled := ok and SpellCheckAvailable;
	3011
	3012	mnuCopy.Enabled := (reBoil.SelLength > 0);
	3013	mnuCut.Enabled := (ok and (reBoil.SelLength > 0));
	3014	mnuSelectAll.Enabled := (reBoil.Lines.Count > 0);
	3015	mnuUndo.Enabled := (reBoil.Perform(EM_CANUNDO, 0, 0) <> 0);
	3016	mnuGroupBoilerplate.Enabled := pnlGroupBP.Visible;
	3017	end
	3018	else
	3019	begin
	3020	mnuInsertObject.Enabled := FALSE;
	3021	mnuInsertField.Enabled := FALSE;
	3022	mnuPaste.Enabled := FALSE;
	3023	mnuErrorCheck.Enabled := FALSE;
	3024	mnuTry.Enabled := FALSE;
	3025	mnuSpellCheck.Enabled := FALSE;
	3026	mnuCheckGrammar.Enabled := FALSE;
	3027	mnuCopy.Enabled := FALSE;
	3028	mnuCut.Enabled := FALSE;
	3029	mnuSelectAll.Enabled := FALSE;
	3030	mnuUndo.Enabled := FALSE;
	3031	mnuGroupBoilerplate.Enabled := FALSE;
	3032	end;
	3033	end;
	3034
	3035	procedure TfrmTemplateEditor.mnuGroupBoilerplateClick(Sender: TObject);
	3036	begin
	3037	mnuGroupCopy.Enabled := (pnlGroupBP.Visible and (reGroupBP.SelLength > 0));
	3038	mnuGroupSelectAll.Enabled := (pnlGroupBP.Visible and (reGroupBP.Lines.Count > 0));
	3039	end;
	3040
	3041	procedure TfrmTemplateEditor.cbShFindOptionClick(Sender: TObject);
	3042	begin
	3043	SetFindNext(tvShared, FALSE);
	3044	if(pnlShSearch.Visible) then edtShSearch.SetFocus;
	3045	end;
	3046
	3047	procedure TfrmTemplateEditor.cbPerFindOptionClick(Sender: TObject);
	3048	begin
	3049	SetFindNext(tvPersonal, FALSE);
	3050	if(pnlPerSearch.Visible) then edtPerSearch.SetFocus;
	3051	end;
	3052
	3053	procedure TfrmTemplateEditor.mnuTemplateClick(Sender: TObject);
	3054	var
	3055	Tree: TTreeView;
	3056
	3057	begin
	3058	FFromMainMenu := TRUE;
	3059	Tree := FCurTree;
	3060	if(assigned(Tree) and assigned(Tree.Selected)) then
	3061	begin
	3062	if(Tree = tvShared) then
	3063	mnuTDelete.Enabled := ((sbShDelete.Visible) and (sbShDelete.Enabled))
	3064	else
	3065	mnuTDelete.Enabled := ((sbPerDelete.Visible) and (sbPerDelete.Enabled));
	3066	if(assigned(Tree) and assigned(Tree.Selected) and assigned(Tree.Selected.Data)) then
	3067	begin
	3068	mnuTCopy.Enabled := (TTemplate(Tree.Selected.Data).RealType in [ttDoc, ttGroup, ttClass]);
	3069	mnuSort.Enabled := (TTemplate(Tree.Selected.Data).RealType in AllTemplateFolderTypes) and
	3070	(Tree.Selected.HasChildren) and
	3071	(Tree.Selected.GetFirstChild.GetNextSibling <> nil);
	3072	end
	3073	else
	3074	begin
	3075	mnuTCopy.Enabled := FALSE;
	3076	mnuSort.Enabled := FALSE;
	3077	end;
	3078	FPasteNode := Tree.Selected;
	3079	mnuTPaste.Enabled := PasteOK;
	3080	end
	3081	else
	3082	begin
	3083	mnuTCopy.Enabled := FALSE;
	3084	mnuTPaste.Enabled := FALSE;
	3085	mnuTDelete.Enabled := FALSE;
	3086	mnuSort.Enabled := FALSE;
	3087	end;
	3088	mnuNewTemplate.Enabled := btnNew.Enabled;
	3089	mnuAutoGen.Enabled := btnNew.Enabled;
	3090	mnuFindShared.Checked := FFindShOn;
	3091	mnuFindPersonal.Checked := FFindPerOn;
	3092	mnuShCollapse.Enabled := dmodShared.NeedsCollapsing(tvShared);
	3093	mnuPerCollapse.Enabled := dmodShared.NeedsCollapsing(tvPersonal);
	3094	end;
	3095
	3096	procedure TfrmTemplateEditor.mnuFindSharedClick(Sender: TObject);
	3097	begin
	3098	FMainMenuTree := tvShared;
	3099	mnuFindTemplatesClick(tvShared);
	3100	end;
	3101
	3102	procedure TfrmTemplateEditor.mnuFindPersonalClick(Sender: TObject);
	3103	begin
	3104	FMainMenuTree := tvPersonal;
	3105	mnuFindTemplatesClick(tvPersonal);
	3106	end;
	3107
	3108	procedure TfrmTemplateEditor.mnuShCollapseClick(Sender: TObject);
	3109	begin
	3110	FMainMenuTree := tvShared;
	3111	mnuCollapseTreeClick(tvShared);
	3112	end;
	3113
	3114	procedure TfrmTemplateEditor.mnuPerCollapseClick(Sender: TObject);
	3115	begin
	3116	FMainMenuTree := tvPersonal;
	3117	mnuCollapseTreeClick(tvPersonal);
	3118	end;
	3119
	3120	procedure TfrmTemplateEditor.pnlShSearchResize(Sender: TObject);
	3121	begin
	3122	if((cbShMatchCase.Width + cbShWholeWords.Width) > pnlShSearch.Width) then
	3123	cbShWholeWords.Left := cbShMatchCase.Width
	3124	else
	3125	cbShWholeWords.Left := pnlShSearch.Width - cbShWholeWords.Width;
	3126	end;
	3127
	3128	procedure TfrmTemplateEditor.pnlPerSearchResize(Sender: TObject);
	3129	begin
	3130	if((cbPerMatchCase.Width + cbPerWholeWords.Width) > pnlPerSearch.Width) then
	3131	cbPerWholeWords.Left := cbPerMatchCase.Width
	3132	else
	3133	cbPerWholeWords.Left := pnlPerSearch.Width - cbPerWholeWords.Width;
	3134	end;
	3135
	3136	procedure TfrmTemplateEditor.pnlPropertiesResize(Sender: TObject);
	3137	begin
	3138	btnNew.Width := pnlProperties.Width;
	3139	end;
	3140
	3141	procedure TfrmTemplateEditor.mbMainResize(Sender: TObject);
	3142	begin
[829]	3143	pnlMenu.Width := mbMain.Width + 4;
	3144	mbMain.Width := pnlMenu.Width - 3;
[456]	3145	end;
	3146
	3147	procedure TfrmTemplateEditor.mnuBPCheckGrammarClick(Sender: TObject);
	3148	begin
	3149	GrammarCheckForControl(reBoil);
	3150	end;
	3151
	3152	procedure TfrmTemplateEditor.mnuSortClick(Sender: TObject);
	3153	var
	3154	Tree: TTreeView;
	3155
	3156	begin
	3157	Tree := FCurTree;
	3158	if(assigned(Tree) and assigned(Tree.Selected) and Tree.Selected.HasChildren) then
	3159	begin
	3160	TTemplate(Tree.Selected.Data).SortChildren;
	3161	Resync([TTemplate(Tree.Selected.Data)]);
	3162	btnApply.Enabled := TRUE;
	3163	end;
	3164	end;
	3165
	3166	procedure TfrmTemplateEditor.pnlBoilerplateCanResize(Sender: TObject;
	3167	var NewWidth, NewHeight: Integer; var Resize: Boolean);
	3168	begin
	3169	if(NewHeight < 40) then Resize := FALSE;
	3170	end;
	3171
	3172	function TfrmTemplateEditor.AutoDel(Template: TTemplate): boolean;
	3173	begin
	3174	if(assigned(Template)) then
	3175	Result := (((Template.ID = '0') or (Template.ID = '')) and
	3176	(Template.PrintName = NewTemplateName) and
	3177	(Template.Boilerplate = ''))
	3178	else
	3179	Result := FALSE;
	3180	end;
	3181
	3182	procedure TfrmTemplateEditor.mnuBPTryClick(Sender: TObject);
	3183	var
	3184	R: TRect;
	3185	Move: boolean;
	3186	tmpl: TTemplate;
	3187	txt: String;
	3188
	3189	begin
	3190	mnuBPErrorCheckClick(nil);
	3191	if(FBPOK) or (reBoil.Lines.Count = 0) then
	3192	begin
	3193	Move := assigned(frmTemplateView);
	3194	if(Move) then
	3195	begin
	3196	R := frmTemplateView.BoundsRect;
	3197	frmTemplateView.Free;
	3198	frmTemplateView := nil;
	3199	end;
	3200	tmpl := TTemplate(FCurTree.Selected.Data);
	3201	tmpl.TemplatePreviewMode := TRUE; // Prevents "Are you sure?" dialog when canceling
	3202	txt := tmpl.Text;
	3203	if(not tmpl.DialogAborted) then
	3204	ShowTemplateData(Self, tmpl.PrintName ,txt);
	3205	if(Move) then
	3206	frmTemplateView.BoundsRect := R;
	3207	tmpl.TemplatePreviewMode := FALSE;
	3208	end;
	3209	end;
	3210
	3211	procedure TfrmTemplateEditor.mnuAutoGenClick(Sender: TObject);
	3212	var
	3213	AName, AText: string;
	3214
	3215	begin
	3216	dmodShared.LoadTIUObjects;
	3217	UpdatePersonalObjects;
[829]	3218	GetAutoGenText(AName, AText, uPersonalObjects); // -------- CQ #8665 - RV ------------
[456]	3219	if(AName <> '') and (AText <> '') then
	3220	begin
	3221	btnNewClick(Self);
	3222	TTemplate(FBtnNewNode.Data).PrintName := AName;
	3223	TTemplate(FBtnNewNode.Data).Boilerplate := AText;
	3224	ShowInfo(FBtnNewNode);
	3225	edtNameOldChange(Self);
	3226	end;
	3227	end;
	3228
	3229	procedure TfrmTemplateEditor.reNotesChange(Sender: TObject);
	3230	var
	3231	Template: TTemplate;
	3232	DoRefresh: boolean;
	3233
	3234	begin
	3235	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected))) then
	3236	begin
	3237	if CanClone(FCurTree.Selected) then
	3238	begin
	3239	DoRefresh := Clone(FCurTree.Selected);
	3240	Template := TTemplate(FCurTree.Selected.Data);
	3241	if assigned(Template) and Template.CanModify then
	3242	begin
	3243	Template.Description := reNotes.Lines.Text;
	3244	UpdateApply(Template);
	3245	if(DoRefresh) then
	3246	begin
	3247	tvShared.Invalidate;
	3248	tvPersonal.Invalidate;
	3249	end;
	3250	end;
	3251	end;
	3252	btnApply.Enabled := TRUE;
	3253	// reNotes.Lines.Text := Template.Description;
	3254	end;
	3255	end;
	3256
	3257	procedure TfrmTemplateEditor.mnuNotesUndoClick(Sender: TObject);
	3258	begin
	3259	reNotes.Perform(EM_UNDO, 0, 0);
	3260	end;
	3261
	3262	procedure TfrmTemplateEditor.mnuNotesCutClick(Sender: TObject);
	3263	begin
	3264	reNotes.CutToClipboard;
	3265	end;
	3266
	3267	procedure TfrmTemplateEditor.mnuNotesCopyClick(Sender: TObject);
	3268	begin
	3269	reNotes.CopyToClipboard;
	3270	end;
	3271
	3272	procedure TfrmTemplateEditor.mnuNotesPasteClick(Sender: TObject);
	3273	begin
	3274	reNotes.SelText := Clipboard.AsText;
	3275	end;
	3276
	3277	procedure TfrmTemplateEditor.mnuNotesSelectAllClick(Sender: TObject);
	3278	begin
	3279	reNotes.SelectAll;
	3280	end;
	3281
	3282	procedure TfrmTemplateEditor.mnuNotesGrammarClick(Sender: TObject);
	3283	begin
	3284	GrammarCheckForControl(reNotes);
	3285	end;
	3286
	3287	procedure TfrmTemplateEditor.mnuNotesSpellingClick(Sender: TObject);
	3288	begin
	3289	SpellCheckForControl(reNotes);
	3290	end;
	3291
	3292	procedure TfrmTemplateEditor.popNotesPopup(Sender: TObject);
	3293	var
	3294	ok: boolean;
	3295
	3296	begin
	3297	ok := not reNotes.ReadOnly;
	3298	mnuNotesPaste.Enabled := (ok and Clipboard.HasFormat(CF_TEXT));
	3299	if(ok) then
	3300	ok := (reNotes.Lines.Count > 0);
	3301	mnuNotesSpelling.Enabled := ok and SpellCheckAvailable;
	3302	mnuNotesGrammar.Enabled := ok and SpellCheckAvailable;
	3303	mnuNotesCopy.Enabled := (reNotes.SelLength > 0);
	3304	mnuNotesCut.Enabled := (ok and (reNotes.SelLength > 0));
	3305	mnuNotesSelectAll.Enabled := (reNotes.Lines.Count > 0);
	3306	mnuNotesUndo.Enabled := (reNotes.Perform(EM_CANUNDO, 0, 0) <> 0);
	3307	end;
	3308
	3309	procedure TfrmTemplateEditor.cbNotesClick(Sender: TObject);
	3310	begin
	3311	pnlNotes.Visible := cbNotes.Checked;
	3312	splNotes.Visible := cbNotes.Checked;
[829]	3313	if cbNotes.Checked then
	3314	begin
	3315	pnlNotes.Height := tmplEditorSplitterNotes;
	3316	pnlNotes.Top := pnlBottom.Top - pnlNotes.Height;
	3317	splNotes.Top := pnlNotes.Top-3;
	3318	end;
[456]	3319	pnlBoilerplateResize(Self);
	3320	end;
	3321
	3322	procedure TfrmTemplateEditor.cbDisplayOnlyClick(Sender: TObject);
	3323	begin
	3324	cbClick(TCheckBox(Sender), BPDisplayOnlyFld);
	3325	end;
	3326
	3327	procedure TfrmTemplateEditor.cbFirstLineClick(Sender: TObject);
	3328	begin
	3329	cbClick(TCheckBox(Sender), BPFirstLineFld);
	3330	end;
	3331
	3332	procedure TfrmTemplateEditor.cbOneItemOnlyClick(Sender: TObject);
	3333	begin
	3334	cbClick(TCheckBox(Sender), BPOneItemOnlyFld);
	3335	end;
	3336
	3337	procedure TfrmTemplateEditor.cbHideDlgItemsClick(Sender: TObject);
	3338	begin
	3339	cbClick(TCheckBox(Sender), BPHideDlgItemsFld);
	3340	end;
	3341
	3342	procedure TfrmTemplateEditor.cbHideItemsClick(Sender: TObject);
	3343	begin
	3344	cbClick(TCheckBox(Sender), BPHideItemsFld);
	3345	end;
	3346
	3347	procedure TfrmTemplateEditor.cbClick(Sender: TCheckBox; Index: integer);
	3348	var
	3349	Template: TTemplate;
	3350
	3351	begin
	3352	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected))) then
	3353	begin
	3354	if CanClone(FCurTree.Selected) then
	3355	begin
	3356	Clone(FCurTree.Selected);
	3357	Template := TTemplate(FCurTree.Selected.Data);
	3358	if assigned(Template) and Template.CanModify then
	3359	begin
	3360	case Index of
	3361	BPDisplayOnlyFld: Template.DisplayOnly := Sender.Checked;
	3362	BPFirstLineFld: Template.FirstLine := Sender.Checked;
	3363	BPOneItemOnlyFld: Template.OneItemOnly := Sender.Checked;
	3364	BPHideDlgItemsFld: Template.HideDlgItems := Sender.Checked;
	3365	BPHideItemsFld: Template.HideItems := Sender.Checked;
	3366	BPIndentFld: Template.IndentItems := Sender.Checked;
	3367	BPLockFld: Template.Lock := Sender.Checked;
	3368	end;
	3369	UpdateApply(Template);
	3370	end;
	3371	end;
	3372	end;
	3373	end;
	3374
	3375	procedure TfrmTemplateEditor.cbIndentClick(Sender: TObject);
	3376	begin
	3377	cbClick(TCheckBox(Sender), BPIndentFld);
	3378	end;
	3379
	3380	procedure TfrmTemplateEditor.mnuToolsClick(Sender: TObject);
	3381	begin
	3382	mnuEditTemplateFields.Enabled := CanEditTemplateFields;
	3383	mnuImportTemplate.Enabled := btnNew.Enabled;
	3384	mnuExportTemplate.Enabled := (assigned(FCurTree) and assigned(FCurTree.Selected) and
	3385	assigned(FCurTree.Selected.Data));
	3386	end;
	3387
	3388	procedure TfrmTemplateEditor.mnuEditTemplateFieldsClick(Sender: TObject);
	3389	begin
	3390	if assigned(frmTemplateObjects) then
	3391	frmTemplateObjects.Hide;
	3392	if assigned(frmTemplateFields) then
	3393	frmTemplateFields.Hide;
	3394	if EditDialogFields and assigned(frmTemplateFields) then
	3395	FreeAndNil(frmTemplateFields);
	3396	end;
	3397
	3398	procedure TfrmTemplateEditor.mnuBPInsertFieldClick(Sender: TObject);
	3399	begin
	3400	if(not assigned(frmTemplateFields)) then
	3401	begin
	3402	frmTemplateFields := TfrmTemplateFields.Create(Self);
	3403	frmTemplateFields.Font := Font;
	3404	frmTemplateFields.re := reBoil;
	3405	frmTemplateFields.AutoLongLines := AutoLongLines;
	3406	end;
	3407	frmTemplateFields.Show;
	3408	end;
	3409
	3410	procedure TfrmTemplateEditor.UpdateInsertsDialogs;
	3411	begin
	3412	if assigned(frmTemplateObjects) then
	3413	frmTemplateObjects.UpdateStatus;
	3414	if assigned(frmTemplateFields) then
	3415	frmTemplateFields.UpdateStatus;
	3416	end;
	3417
	3418	procedure TfrmTemplateEditor.mnuExportTemplateClick(Sender: TObject);
	3419	var
	3420	Tmpl, Flds: TStringList;
	3421	i: integer;
	3422	XMLDoc: IXMLDOMDocument;
	3423	err: boolean;
	3424
	3425	begin
	3426	err := FALSE;
	3427	if(assigned(FCurTree) and assigned(FCurTree.Selected) and assigned(FCurTree.Selected.Data)) then
	3428	begin
	3429	dlgExport.FileName := ValidFileName(TTemplate(FCurTree.Selected.Data).PrintName);
	3430	if dlgExport.Execute then
	3431	begin
	3432	Tmpl := TStringList.Create;
	3433	try
	3434	Flds := TStringList.Create;
	3435	try
	3436	Tmpl.Add('<'+XMLHeader+'>');
	3437	if TTemplate(FCurTree.Selected.Data).CanExportXML(Tmpl, Flds, 2) then
	3438	begin
	3439	if (Flds.Count > 0) then begin
	3440	ExpandEmbeddedFields(Flds);
[829]	3441	FastAssign(ExportTemplateFields(Flds), Flds);
[456]	3442	for i := 0 to Flds.Count-1 do
	3443	Flds[i] := ' ' + Flds[i];
[829]	3444	FastAddStrings(Flds, Tmpl);
[456]	3445	end; {if}
	3446	Tmpl.Add('</'+XMLHeader+'>');
	3447	try
	3448	XMLDoc := CoDOMDocument.Create;
	3449	try
	3450	XMLDoc.preserveWhiteSpace := TRUE;
	3451	XMLDoc.LoadXML(Tmpl.Text);
	3452	XMLDoc.Save(dlgExport.FileName);
	3453	finally
	3454	XMLDoc := nil;
	3455	end;
	3456	except
	3457	InfoBox(Format(NoIE5, ['Export']), NoIE5Header, MB_OK);
	3458	err := TRUE;
	3459	end;
	3460	if not err then
	3461	InfoBox('Template ' + TTemplate(FCurTree.Selected.Data).PrintName +
	3462	' Exported.', 'Template Exported', MB_OK);
	3463	end;
	3464	finally
	3465	Flds.Free;
	3466	end;
	3467	finally
	3468	Tmpl.Free;
	3469	end;
	3470	end;
	3471	end;
	3472	end;
	3473
	3474	procedure TfrmTemplateEditor.mnuImportTemplateClick(Sender: TObject);
	3475	const
	3476	Filter1 = 'Template Files\|*.txml';
	3477	WordFilter = '\|Word Documents\|.doc;.dot';
	3478	Filter2 = '\|XML Files\|.xml\|All Files\|.*';
	3479
	3480	var
	3481	XMLDoc: IXMLDOMDocument;
	3482	RootElement: IXMLDOMElement;
	3483	ImportedTemplate: TTemplate;
	3484	AppData, Flds, ResultSet: TStringList;
	3485	tmp,j,p3: string;
	3486	err, ok, changes, xmlerr: boolean;
	3487	i: integer;
	3488	choice: word;
	3489
	3490	procedure ClearFields;
	3491	begin
	3492	Flds.Text := '';
	3493	ResultSet.Text := '';
	3494	end;
	3495
	3496	begin
	3497	tmp := Filter1;
	3498	err := FALSE;
	3499	if WordImportActive then
	3500	tmp := tmp + WordFilter;
	3501	tmp := tmp + Filter2;
	3502	dlgImport.Filter := tmp;
	3503	if btnNew.Enabled and dlgImport.Execute then
	3504	begin
	3505	tmp := ExtractFileExt(dlgImport.FileName);
	3506	if(WordImportActive and ((CompareText(tmp,'.doc') = 0) or
	3507	(CompareText(tmp,'.dot') = 0))) then
	3508	AppData := TStringList.Create
	3509	else
	3510	AppData := nil;
	3511	try
	3512	try
	3513	XMLDoc := CoDOMDocument.Create;
	3514	except
	3515	InfoBox(Format(NoIE5, ['Import']), NoIE5Header, MB_OK);
	3516	exit;
	3517	end;
	3518	try
	3519	if assigned(AppData) then
	3520	begin
	3521	try
	3522	ok := GetXMLFromWord(dlgImport.FileName, AppData);
	3523	except
	3524	ok := FALSE;
	3525	err := TRUE;
	3526	end;
	3527	end
	3528	else
	3529	ok := TRUE;
	3530	if ok and assigned(XMLDoc) then
	3531	begin
	3532	XMLDoc.preserveWhiteSpace := TRUE;
	3533	if assigned(AppData) then
	3534	XMLDoc.LoadXML(AppData.Text)
	3535	else
	3536	XMLDoc.Load(dlgImport.FileName);
	3537	RootElement := XMLDoc.DocumentElement;
	3538	if not assigned(RootElement) then
	3539	XMLImportError(0);
	3540	try
	3541	if(RootElement.tagName <> XMLHeader)then
	3542	XMLImportError(0)
	3543	else
	3544	begin
	3545	ImportedTemplate := nil;
	3546	FXMLTemplateElement := FindXMLElement(RootElement, XMLTemplateTag);
	3547	if assigned(FXMLTemplateElement) then
	3548	begin
	3549	FXMLFieldElement := FindXMLElement(RootElement, XMLTemplateFieldsTag);
	3550	if(assigned(FXMLFieldElement)) then
	3551	begin
	3552	Flds := TStringList.Create;
	3553	ResultSet := TStringList.Create;
	3554	try
	3555	Flds.Text := FXMLFieldElement.Get_XML;
	3556	choice := IDOK;
	3557	changes := FALSE;
	3558	Application.ProcessMessages;
	3559	if not BuildTemplateFields(Flds) then //Calls RPC to transfer all field XML
	3560	choice := IDCANCEL; //for processing
	3561	Flds.Text := '';
	3562	Application.ProcessMessages;
	3563	if choice = IDOK then
	3564	CheckTemplateFields(Flds);
	3565	if Flds.Count > 0 then
	3566	begin
	3567	for i := 1 to Flds.Count do
	3568	begin
	3569	j := piece(Flds[i-1],U,2);
	3570	if (j = '0') or (j = '2') then
	3571	begin
	3572	p3 := piece(Flds[i-1],U,3);
	3573	if p3 = 'XML FORMAT ERROR' then
	3574	choice := IDCANCEL;
	3575	changes := TRUE;
	3576	if j = '2' then begin
	3577	j := Flds[i-1];
	3578	SetPiece(j,U,2,'1');
	3579	Flds[i-1] := j
	3580	end;
	3581	end;
	3582	end;
	3583	end
	3584	else
	3585	choice := IDCANCEL;
	3586	if choice <> IDOK then
	3587	InfoBox(iMessage2+iMessage3, 'Error', MB_OK or MB_ICONERROR)
	3588	else
	3589	if (not CanEditTemplateFields) AND
	3590	changes {(there is at least one new field)} then
	3591	begin
	3592	choice := InfoBox(iMessage, 'Warning', MB_OKCANCEL or MB_ICONWARNING);
	3593	Flds.Text := '';
	3594	end;
	3595	if choice <> IDCANCEL then
	3596	begin
	3597	FImportingFromXML := TRUE;
	3598	try
	3599	btnNewClick(Self);
	3600	ImportedTemplate := TTemplate(FBtnNewNode.Data);
	3601	finally
	3602	FImportingFromXML := FALSE;
	3603	end; {try}
	3604	Application.ProcessMessages;
	3605	if assigned(ImportedTemplate) and (Flds.Count > 0) then
	3606	if not ImportLoadedFields(ResultSet) then begin
	3607	InfoBox(iMessage2+iMessage3, 'Error', MB_OK or MB_ICONERROR);
	3608	ClearFields;
	3609	choice := IDCANCEL;
	3610	end;//if
	3611	if Flds.Count = 0 then
	3612	choice := IDCANCEL;
	3613	end {if choice <> mrCancel}
	3614	else
	3615	ClearFields;
	3616
	3617	xmlerr := FALSE;
	3618	if (Flds.Count > 0) and
	3619	(ResultSet.Count > 0) and
	3620	(Flds.Count = ResultSet.Count) then
	3621	for i := 0 to Flds.Count-1 do begin
	3622	if piece(ResultSet[i],U,2) = '0' then begin
	3623	j := piece(Flds[i],U,1) + U + '0' + U + piece(ResultSet[i],U,3);
	3624	Flds[i] := j;
	3625	end
	3626	end
	3627	else
	3628	xmlerr := TRUE;
	3629
	3630	if xmlerr and (choice <> IDCANCEL) then begin
	3631	InfoBox(iMessage2, 'Warning', MB_OK or MB_ICONWARNING);
	3632	ClearFields;
	3633	end;
	3634
	3635	i := 0;
	3636	while (i < Flds.Count) do begin
	3637	if Piece(Flds[i], U, 2) <> '0' then
	3638	Flds.Delete(i)
	3639	else
	3640	inc(i);
	3641	end;//while
	3642	if(Flds.Count > 0) then
	3643	begin
	3644	if assigned(frmTemplateFields) then
	3645	FreeAndNil(frmTemplateFields);
	3646	ImportedTemplate.UpdateImportedFieldNames(Flds);
	3647	if not assigned(AppData) then
	3648	begin
	3649	for i := 0 to Flds.Count-1 do
	3650	Flds[i] := ' Field "' + Piece(Flds[i],U,1) + '" has been renamed to "'+
	3651	Piece(Flds[i],U,3) + '"';
	3652	if Flds.Count = 1 then
	3653	tmp := 'A template field has'
	3654	else
	3655	tmp := IntToStr(Flds.Count) + ' template fields have';
	3656	Flds.Insert(0,tmp + ' been imported with the same name as');
	3657	Flds.Insert(1,'existing template fields, but with different field definitions.');
	3658	Flds.Insert(2,'These imported template fields have been renamed as follows:');
	3659	Flds.Insert(3,'');
	3660	InfoBox(Flds.Text, 'Information', MB_OK or MB_ICONINFORMATION);
	3661	end;
	3662	end;
	3663	finally
	3664	Flds.Free;
	3665	ResultSet.Free;
	3666	end;
	3667	end
	3668	else {There are no fields to consider...}
	3669	begin
	3670	FImportingFromXML := TRUE;
	3671	try
	3672	btnNewClick(Self);
	3673	ImportedTemplate := TTemplate(FBtnNewNode.Data);
	3674	finally
	3675	FImportingFromXML := FALSE;
	3676	end; {try}
	3677	end;
	3678	end;
	3679	if assigned(ImportedTemplate) then
	3680	ShowInfo(FBtnNewNode);
	3681	end;
	3682	finally
	3683	RootElement := nil;
	3684	end;
	3685	end;
	3686	finally
	3687	XMLDoc := nil;
	3688	end;
	3689	finally
	3690	if assigned(AppData) then
	3691	begin
	3692	AppData.Free;
	3693	if err then
	3694	InfoBox('An error occured while Importing Word Document. Make sure Word is closed and try again.','Import Error', MB_OK);
	3695	end;
	3696	end;
	3697	end;
	3698	end;
	3699
	3700	procedure TfrmTemplateEditor.cbxTypeDrawItem(Control: TWinControl;
	3701	Index: Integer; Rect: TRect; State: TOwnerDrawState);
	3702	var
	3703	ImgIdx: integer;
	3704
	3705	begin
	3706	cbxType.Canvas.FillRect(Rect);
	3707	case IdxForced[FForceContainer, Index] of
	3708	tiTemplate: ImgIdx := 4;
	3709	tiFolder: ImgIdx := 3;
	3710	tiGroup: ImgIdx := 5;
	3711	tiDialog: ImgIdx := 23;
	3712	tiRemDlg: ImgIdx := 27;
	3713	tiCOMObj: ImgIdx := 28;
	3714	else
	3715	ImgIdx := ord(tiNone);
	3716	end;
	3717	if ImgIdx >= 0 then
	3718	dmodShared.imgTemplates.Draw(cbxType.Canvas, Rect.Left+1, Rect.Top+1, ImgIdx);
	3719	if Index >= 0 then
	3720	cbxType.Canvas.TextOut(Rect.Left+21, Rect.Top+2, cbxType.Items[Index]);
	3721	end;
	3722
	3723	procedure TfrmTemplateEditor.cbxTypeChange(Sender: TObject);
	3724	var
	3725	i,tg: integer;
	3726	Template: TTemplate;
	3727	ttyp: TTemplateType;
	3728	Node: TTreeNode;
	3729	idx: TTypeIndex;
	3730
	3731	begin
	3732	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected))) then
	3733	begin
	3734	tg := cbxType.ItemIndex;
	3735	if tg >= 0 then
	3736	begin
	3737	if CanClone(FCurTree.Selected) then
	3738	begin
	3739	idx := IdxForced[FForceContainer, tg];
	3740	if(idx = tiRemDlg) and (not (GetLinkType(FCurTree.Selected) in [ltNone, ltTitle])) then
	3741	begin
	3742	FUpdating := TRUE;
	3743	try
	3744	cbxType.ItemIndex := ord(tiTemplate);
	3745	finally
	3746	FUpdating := FALSE;
	3747	end;
[829]	3748	ShowMsg('Can not assign a Reminder Dialog to a Reason for Request');
[456]	3749	end
	3750	else
	3751	begin
	3752	Clone(FCurTree.Selected);
	3753	Template := TTemplate(FCurTree.Selected.Data);
	3754	if assigned(Template) and Template.CanModify then
	3755	begin
	3756	ttyp := TypeTag[idx];
	3757	if(not FForceContainer) or (not (idx in [tiTemplate, tiRemDlg])) then
	3758	begin
	3759	if(ttyp = ttDialog) then
	3760	begin
	3761	Template.Dialog := TRUE;
	3762	ttyp := ttGroup;
	3763	end
	3764	else
	3765	Template.Dialog := FALSE;
	3766	Template.RealType := ttyp;
	3767	if(Template.RealType = ttDoc) and (idx = tiRemDlg) then
	3768	Template.IsReminderDialog := TRUE
	3769	else
	3770	Template.IsReminderDialog := FALSE;
	3771	if(Template.RealType = ttDoc) and (idx = tiCOMObj) then
	3772	Template.IsCOMObject := TRUE
	3773	else
	3774	Template.IsCOMObject := FALSE;
	3775	UpdateApply(Template);
	3776	end;
	3777	for i := 0 to Template.Nodes.Count-1 do
	3778	begin
	3779	Node := TTreeNode(Template.Nodes.Objects[i]);
	3780	Node.ImageIndex := dmodShared.ImgIdx(Node);
	3781	Node.SelectedIndex := dmodShared.ImgIdx(Node);
	3782	end;
	3783	tvShared.Invalidate;
	3784	tvPersonal.Invalidate;
	3785	Node := FCurTree.Selected;
	3786	tvTreeChange(TTreeView(Node.TreeView), Node);
	3787	end;
	3788	end;
	3789	end;
	3790	end;
	3791	end;
	3792	end;
	3793
	3794	procedure TfrmTemplateEditor.cbxRemDlgsChange(Sender: TObject);
	3795	var
	3796	Template: TTemplate;
	3797
	3798	begin
	3799	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected)) and
	3800	FCanDoReminders) then
	3801	begin
	3802	if CanClone(FCurTree.Selected) then
	3803	begin
	3804	Clone(FCurTree.Selected);
	3805	Template := TTemplate(FCurTree.Selected.Data);
	3806	if assigned(Template) and Template.CanModify then
	3807	begin
	3808	if cbxRemDlgs.ItemIndex < 0 then
	3809	Template.ReminderDialog := ''
	3810	else
	3811	Template.ReminderDialog := cbxRemDlgs.Items[cbxRemDlgs.ItemIndex];
	3812	UpdateApply(Template);
	3813	end;
	3814	end;
	3815	end;
	3816	end;
	3817
	3818	procedure TfrmTemplateEditor.mnuTemplateIconLegendClick(Sender: TObject);
	3819	begin
	3820	ShowIconLegend(ilTemplates, TRUE);
	3821	end;
	3822
	3823	procedure TfrmTemplateEditor.cbLongLinesClick(Sender: TObject);
	3824	begin
	3825	pnlBoilerplateResize(Self);
	3826	pnlBoilerplateResize(Self); // Second Call is Needed!
	3827	end;
	3828
	3829	procedure TfrmTemplateEditor.AutoLongLines(Sender: TObject);
	3830	begin
	3831	cbLongLines.Checked := TRUE;
	3832	end;
	3833
[829]	3834	(*procedure TfrmTemplateEditor.UpdatePersonalObjects;
[456]	3835	var
	3836	i: integer;
	3837
	3838	begin
	3839	if not assigned(FPersonalObjects) then
	3840	begin
	3841	FPersonalObjects := TStringList.Create;
	3842	GetAllowedPersonalObjects;
	3843	for i := 0 to RPCBrokerV.Results.Count-1 do
	3844	FPersonalObjects.Add(Piece(RPCBrokerV.Results[i],U,1));
	3845	FPersonalObjects.Sorted := TRUE;
	3846	end;
[829]	3847	end;*)
[456]	3848
	3849	(*function TfrmTemplateEditor.ModifyAllowed(const Node: TTreeNode): boolean;
	3850	var
	3851	tmpl: TTemplate;
	3852
	3853	function GetFirstPersonalNode(Node: TTreeNode): TTreeNode;
	3854	begin
	3855	Result := Node;
	3856	if assigned(Node.Parent) and (TTemplate(Node.Data).PersonalOwner <> User.DUZ) then
	3857	Result := GetFirstPersonalNode(Node.Parent);
	3858	end;
	3859
	3860	begin
	3861	if(assigned(Node)) then
	3862	begin
	3863	if (TTreeView(Node.TreeView) = tvPersonal) then
	3864	Result := TTemplate(GetFirstPersonalNode(Node).Data).CanModify
	3865	else
	3866	Result := TRUE;
	3867	end
	3868	else
	3869	Result := FALSE;
	3870	if Result then
	3871	begin
	3872	tmpl := TTemplate(Node.Data);
	3873	if (tmpl.PersonalOwner = 0) or (tmpl.PersonalOwner = User.DUZ) then
	3874	Result := tmpl.CanModify;
	3875	end;
	3876	end;
	3877	*)
	3878
	3879	{ Returns TRUE if Cloning is not needed or if Cloning is needed and
	3880	the top personal Node in the tree is locked. }
	3881	function TfrmTemplateEditor.CanClone(const Node: TTreeNode): boolean;
	3882	var
	3883	Template: TTemplate;
	3884
	3885	function GetFirstPersonalNode(Node: TTreeNode): TTreeNode;
	3886	begin
	3887	Result := Node;
	3888	if assigned(Node.Parent) and (TTemplate(Node.Data).PersonalOwner <> User.DUZ) then
	3889	Result := GetFirstPersonalNode(Node.Parent);
	3890	end;
	3891
	3892	begin
	3893	if(assigned(Node)) and assigned(Node.Data) then
	3894	begin
	3895	if (TTreeView(Node.TreeView) = tvPersonal) then
	3896	begin
	3897	Template := TTemplate(Node.Data);
	3898	if Template.IsCOMObject or (Template.FileLink <> '') then
	3899	Result := FALSE
	3900	else
	3901	Result := TTemplate(GetFirstPersonalNode(Node).Data).CanModify
	3902	end
	3903	else
	3904	Result := TRUE;
	3905	end
	3906	else
	3907	Result := FALSE;
	3908	end;
	3909
	3910	procedure TfrmTemplateEditor.UpdateApply(Template: TTemplate);
	3911	begin
	3912	if(not btnApply.Enabled) then
	3913	btnApply.Enabled := Template.Changed;
	3914	end;
	3915
	3916	procedure TfrmTemplateEditor.TemplateLocked(Sender: TObject);
	3917	begin
	3918	Resync([TTemplate(Sender)]);
[829]	3919	ShowMsg(Format(TemplateLockedText, [TTemplate(Sender).PrintName]));
[456]	3920	end;
	3921
	3922	procedure TfrmTemplateEditor.cbLockClick(Sender: TObject);
	3923	begin
	3924	cbClick(TCheckBox(Sender), BPLockFLD);
	3925	end;
	3926
	3927	procedure TfrmTemplateEditor.mnuRefreshClick(Sender: TObject);
	3928	begin
	3929	if btnApply.Enabled then
	3930	begin
	3931	if InfoBox('All changes must be saved before you can Refresh. Save Changes?',
	3932	'Confirmation', MB_YESNO or MB_ICONQUESTION) <> IDYES then
	3933	exit;
	3934	end;
	3935	btnApplyClick(Sender);
	3936	if BtnApply.Enabled then
	3937	InfoBox('Save not completed - unable to refresh.', 'Error', MB_OK or MB_ICONERROR)
	3938	else
	3939	RefreshData;
	3940	end;
	3941
	3942	procedure TfrmTemplateEditor.RefreshData;
	3943	var
	3944	exp1, exp2, s1, s2, t1, t2: string;
	3945	focus: TWinControl;
	3946
	3947	begin
	3948	focus := FCurTree;
	3949	exp1 := tvShared.GetExpandedIDStr(1, ';');
	3950	exp2 := tvPersonal.GetExpandedIDStr(1, ';');
	3951	s1 := tvShared.GetNodeID(TORTreeNode(tvShared.Selected),1,';');
	3952	s2 := tvPersonal.GetNodeID(TORTreeNode(tvPersonal.Selected),1,';');
	3953	t1 := tvShared.GetNodeID(TORTreeNode(tvShared.TopItem),1,';');
	3954	t2 := tvPersonal.GetNodeID(TORTreeNode(tvPersonal.TopItem),1,';');
	3955	tvPersonal.Items.BeginUpdate;
	3956	try
	3957	tvShared.Items.BeginUpdate;
	3958	try
	3959	ReleaseTemplates;
	3960	tvPersonal.Items.Clear;
	3961	tvShared.Items.Clear;
	3962	InitTrees;
	3963	tvShared.SetExpandedIDStr(1, ';', exp1);
	3964	tvShared.TopItem := tvShared.FindPieceNode(t1,1,';');
	3965	tvShared.Selected := tvShared.FindPieceNode(s1,1,';');
	3966	tvPersonal.SetExpandedIDStr(1, ';', exp2);
	3967	tvPersonal.TopItem := tvPersonal.FindPieceNode(t2,1,';');
	3968	tvPersonal.Selected := tvPersonal.FindPieceNode(s2,1,';');
	3969	finally
	3970	tvShared.Items.EndUpdate;
	3971	end;
	3972	finally
	3973	tvPersonal.Items.EndUpdate;
	3974	end;
	3975	ActiveControl := focus;
	3976	end;
	3977
	3978	procedure TfrmTemplateEditor.InitTrees;
	3979	begin
	3980	LoadTemplateData;
	3981	if(not assigned(RootTemplate)) then
	3982	SaveTemplate(AddTemplate('0^R^A^Shared Templates'),-1);
	3983	if(not assigned(MyTemplate)) then
	3984	AddTemplate('0^P^A^My Templates^^^'+IntToStr(User.DUZ));
	3985	dmodShared.AddTemplateNode(tvPersonal, FPersonalEmptyNodeCount, MyTemplate);
	3986	dmodShared.AddTemplateNode(tvShared, FSharedEmptyNodeCount, RootTemplate);
	3987	if (UserTemplateAccessLevel = taEditor) then
	3988	begin
	3989	if CanEditLinkType(ttTitles) then
	3990	dmodShared.AddTemplateNode(tvShared, FSharedEmptyNodeCount, TitlesTemplate);
	3991	if CanEditLinkType(ttConsults) then
	3992	dmodShared.AddTemplateNode(tvShared, FSharedEmptyNodeCount, ConsultsTemplate);
	3993	if CanEditLinkType(ttProcedures) then
	3994	dmodShared.AddTemplateNode(tvShared, FSharedEmptyNodeCount, ProceduresTemplate);
	3995	end;
	3996	end;
	3997
	3998	procedure TfrmTemplateEditor.reResizeRequest(Sender: TObject;
	3999	Rect: TRect);
	4000	var
	4001	R: TRect;
	4002
	4003	begin
	4004	R := TRichEdit(Sender).ClientRect;
	4005	if (FLastRect.Right <> R.Right) or
	4006	(FLastRect.Bottom <> R.Bottom) or
	4007	(FLastRect.Left <> R.Left) or
	4008	(FLastRect.Top <> R.Top) then
	4009	begin
	4010	FLastRect := R;
	4011	pnlBoilerplateResize(Self);
	4012	end;
	4013	end;
	4014
	4015	procedure TfrmTemplateEditor.reBoilSelectionChange(Sender: TObject);
	4016	begin
	4017	UpdateXY(reBoil, lblBoilCol, lblBoilRow);
	4018	end;
	4019
	4020	procedure TfrmTemplateEditor.reGroupBPSelectionChange(Sender: TObject);
	4021	begin
	4022	UpdateXY(reGroupBP, lblGroupCol, lblGroupRow);
	4023	end;
	4024
	4025	procedure TfrmTemplateEditor.UpdateXY(re: TRichEdit; lblX, lblY: TLabel);
	4026	var
	4027	p: TPoint;
	4028
	4029	begin
	4030	p := re.CaretPos;
	4031	lblY.Caption := 'Line: ' + inttostr(p.y + 1);
	4032	lblX.Caption := 'Column: ' + inttostr(p.x + 1);
	4033	end;
	4034
	4035	procedure TfrmTemplateEditor.cbxCOMObjChange(Sender: TObject);
	4036	var
	4037	Template: TTemplate;
	4038
	4039	begin
	4040	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected)) and
	4041	FCanDoCOMObjects and (FCurTree = tvShared)) then
	4042	begin
	4043	Template := TTemplate(FCurTree.Selected.Data);
	4044	if assigned(Template) and Template.CanModify then
	4045	begin
	4046	if cbxCOMObj.ItemIndex < 0 then
	4047	Template.COMObject := 0
	4048	else
	4049	Template.COMObject := cbxCOMObj.ItemID;
	4050	UpdateApply(Template);
	4051	end;
	4052	end;
	4053	end;
	4054
	4055	procedure TfrmTemplateEditor.edtCOMParamChange(Sender: TObject);
	4056	var
	4057	Template: TTemplate;
	4058
	4059	begin
	4060	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected)) and
	4061	FCanDoCOMObjects and (FCurTree = tvShared)) then
	4062	begin
	4063	Template := TTemplate(FCurTree.Selected.Data);
	4064	if assigned(Template) and Template.CanModify then
	4065	begin
	4066	Template.COMParam := edtCOMParam.Text;
	4067	UpdateApply(Template);
	4068	end;
	4069	end;
	4070	end;
	4071
	4072	function TfrmTemplateEditor.GetLinkType(const ANode: TTreeNode): TTemplateLinkType;
	4073	var
	4074	Node: TTreeNode;
	4075
	4076	begin
	4077	Result := ltNone;
	4078	if assigned(ANode) then
	4079	begin
	4080	if(not assigned(ANode.Data)) or (TTemplate(ANode.Data).RealType <> ttClass) then
	4081	begin
	4082	Node := ANode.Parent;
	4083	repeat
	4084	if assigned(Node) and assigned(Node.Data) then
	4085	begin
	4086	if (TTemplate(Node.Data).FileLink <> '') then
	4087	Node := nil
	4088	else
	4089	if (TTemplate(Node.Data).RealType in AllTemplateLinkTypes) then
	4090	begin
	4091	case TTemplate(Node.Data).RealType of
	4092	ttTitles: Result := ltTitle;
	4093	ttConsults: Result := ltConsult;
	4094	ttProcedures: Result := ltProcedure;
	4095	end;
	4096	end
	4097	else
	4098	Node := Node.Parent;
	4099	end
	4100	else
	4101	Node := nil;
	4102	until(Result <> ltNone) or (not assigned(Node));
	4103	end;
	4104	end;
	4105	end;
	4106
	4107	procedure TfrmTemplateEditor.cbxLinkNeedData(Sender: TObject;
	4108	const StartFrom: String; Direction, InsertAt: Integer);
	4109	var
	4110	tmpSL: TStringList;
	4111	i: integer;
	4112	tmp: string;
	4113
	4114	begin
	4115	tmpSL := TStringList.Create;
	4116	try
	4117	case TTemplateLinkType(pnlLink.Tag) of
[829]	4118	ltTitle: FastAssign(SubSetOfAllTitles(StartFrom, Direction), tmpSL);
[456]	4119	// ltConsult:
	4120	ltProcedure:
	4121	begin
[829]	4122	FastAssign(SubSetOfProcedures(StartFrom, Direction), tmpSL);
[456]	4123	for i := 0 to tmpSL.Count-1 do
	4124	begin
	4125	tmp := tmpSL[i];
	4126	setpiece(tmp,U,1,piece(piece(tmp,U,4),';',1));
	4127	tmpSL[i] := tmp;
	4128	end;
	4129	end;
	4130	end;
	4131	cbxLink.ForDataUse(tmpSL);
	4132	finally
	4133	tmpSL.Free;
	4134	end;
	4135	end;
	4136
	4137	procedure TfrmTemplateEditor.cbxLinkChange(Sender: TObject);
	4138	var
	4139	Template,LinkTemplate: TTemplate;
[829]	4140	update: boolean;
[456]	4141
	4142	begin
	4143	if((not FUpdating) and (assigned(FCurTree)) and (assigned(FCurTree.Selected)) and
	4144	(FCurTree = tvShared)) then
	4145	begin
	4146	Template := TTemplate(FCurTree.Selected.Data);
	4147	if assigned(Template) and Template.CanModify then
	4148	begin
[829]	4149	update := true;
[456]	4150	if cbxLink.ItemIEN > 0 then
	4151	begin
	4152	LinkTemplate := GetLinkedTemplate(cbxLink.ItemID, TTemplateLinkType(pnlLink.tag));
	4153	if (assigned(LinkTemplate) and (LinkTemplate <> Template)) then
	4154	begin
[829]	4155	ShowMsg(GetLinkName(cbxLink.ItemID, TTemplateLinkType(pnlLink.tag)) +
[456]	4156	' is already assigned to another template.');
[829]	4157	cbxLink.SelectByID(Template.LinkIEN);
	4158	update := False;
	4159	end
	4160	else
	4161	begin
	4162	Template.FileLink := ConvertFileLink(cbxLink.ItemID, TTemplateLinkType(pnlLink.tag));
	4163	if Template.LinkName <> '' then
	4164	edtName.Text := copy(Template.LinkName,1,edtName.MaxLength);
[456]	4165	end;
	4166	end
	4167	else
	4168	Template.FileLink := '';
[829]	4169	if update then
	4170	UpdateApply(Template);
[456]	4171	end;
	4172	end;
	4173	end;
	4174
	4175	procedure TfrmTemplateEditor.reBoilKeyUp(Sender: TObject; var Key: Word;
	4176	Shift: TShiftState);
	4177	begin
	4178	if FNavigatingTab then
	4179	begin
	4180	if ssShift in Shift then
	4181	FindNextControl(Sender as TWinControl, False, True, False).SetFocus //previous control
	4182	else if ssCtrl in Shift then
	4183	FindNextControl(Sender as TWinControl, True, True, False).SetFocus; //next control
	4184	FNavigatingTab := False;
	4185	end;
	4186	if (key = VK_ESCAPE) then begin
	4187	FindNextControl(Sender as TWinControl, False, True, False).SetFocus; //previous control
	4188	key := 0;
	4189	end;
	4190	end;
	4191
	4192	procedure TfrmTemplateEditor.reBoilKeyPress(Sender: TObject;
	4193	var Key: Char);
	4194	begin
	4195	if FNavigatingTab then
	4196	Key := #0; //Disable shift-tab processinend;
	4197	end;
	4198
	4199	procedure TfrmTemplateEditor.reBoilKeyDown(Sender: TObject; var Key: Word;
	4200	Shift: TShiftState);
	4201	begin
	4202	//The navigating tab controls were inadvertantently adding tab characters
	4203	//This should fix it
	4204	FNavigatingTab := (Key = VK_TAB) and ([ssShift,ssCtrl] * Shift <> []);
	4205	if FNavigatingTab then
	4206	Key := 0;
	4207	end;
	4208
	4209	end.
	4210

Note: See TracBrowser for help on using the repository browser.

Download in other formats: