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

Line
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,
20	uTemplates, Menus, ImgList, Clipbrd, ToolWin, MenuBar, TypInfo, MSXML_TLB, fBase508Form,
21	VA508AccessibilityManager, VA508ImageListLabeler;
22
23	type
24	TTemplateTreeControl = (tcDel, tcUp, tcDown, tcLbl, tcCopy);
25	TTemplateTreeType = (ttShared, ttPersonal);
26
27	TfrmTemplateEditor = class(TfrmBase508Form)
28	splMain: TSplitter;
29	pnlBottom: TPanel;
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;
212	imgLblTemplates: TVA508ImageListLabeler;
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);
348	procedure FormClose(Sender: TObject; var Action: TCloseAction);
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;
389	//FPersonalObjects: TStringList;
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);
419	//procedure UpdatePersonalObjects;
420	procedure UpdateApply(Template: TTemplate);
421	procedure TemplateLocked(Sender: TObject);
422	procedure InitTrees;
423	procedure AdjustControls4FontChange;
424	procedure ShowGroupBoilerplate(Visible: boolean);
425	function GetLinkType(const ANode: TTreeNode): TTemplateLinkType;
426	end;
427
428	procedure EditTemplates(Form: TForm; NewTemplate: boolean = FALSE; CopiedText: string = ''; Shared: boolean = FALSE);
429
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
441	implementation
442
443	{$R *.DFM}
444
445	uses dShared, uCore, rTemplates, fTemplateObjects, uSpell, fTemplateView,
446	fTemplateAutoGen, fDrawers, fTemplateFieldEditor, fTemplateFields, XMLUtils,
447	fIconLegend, uReminders, uConst, rCore, rEventHooks, rConsults, VAUtils,
448	rMisc, fFindingTemplates;
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
516	if IsPublishedProp(Form, DrawersProperty) then
517	Drawers := TFrmDrawers(GetOrdProp(Form, DrawersProperty));
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;
741	SetFormPosition(Self);
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);
891	UpdateReadOnlyColorScheme(reNotes, reNotes.ReadOnly);
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;
909	UpdateReadOnlyColorScheme(reBoil, not ok);
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
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
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;
1008	FastAssign(LoadServiceListWithSynonyms(1), FConsultServices);
1009	SortByPiece(FConsultServices, U, 2);
1010	end;
1011	FastAssign(FConsultServices, cbxLink.Items);
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;
1194	ShowGroupBoilerplate(False);
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
1218	begin
1219	pnlGroupBP.Height := pnlBoilerplate.Height-29;
1220	end;
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;
1473	UpdateReadOnlyColorScheme(reBoil, TRUE);
1474	UpdateInsertsDialogs;
1475	end;
1476	ShowGroupBoilerplate(ItemOK);
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;
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 -------------
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
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
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);
2262	if FCanEditShared then
2263	AdjustControls4FontChange;
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
2386	Found: TTreeNode;
2387	edtSearch: TEdit;
2388	IsNext: boolean;
2389	FindNext: boolean;
2390	FindWholeWords: boolean;
2391	FindCase: boolean;
2392	Tree: TTreeView;
2393	LastFoundNode, TmpNode: TTreeNode;
2394	// S1,S2: string;
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
2417	IsNext := ((FindNext) and assigned (LastFoundNode));
2418	if IsNext then
2419
2420	TmpNode := LastFoundNode
2421	else
2422	TmpNode := Tree.Items.GetFirstNode;
2423	FInternalHiddenExpand := TRUE;
2424	try
2425	Found := FindTemplate(edtSearch.Text, Tree, Self, TmpNode,
2426	IsNext, not FindCase, FindWholeWords);
2427	finally
2428	FInternalHiddenExpand := FALSE;
2429	end;
2430	if Assigned(Found) then
2431	begin
2432	Tree.Selected := Found;
2433	if(Tree = tvShared) then
2434	FLastFoundShNode := Found
2435	else
2436	FLastFoundPerNode := Found;
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);
2525	AdjustControls4FontChange;
2526	MoveCopyButtons;
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;
2544	if uPersonalObjects.Count > 0 then // -------- CQ #8665 - RV ------------
2545	begin
2546	DoIt := FALSE;
2547	for i := 0 to dmodShared.TIUObjects.Count-1 do
2548	if uPersonalObjects.IndexOf(Piece(dmodShared.TIUObjects[i],U,2)) >= 0 then // -------- CQ #8665 - RV ------------
2549	frmTemplateObjects.cboObjects.Items.Add(dmodShared.TIUObjects[i]);
2550	end;
2551	end;
2552	if DoIt then
2553	FastAssign(dmodShared.TIUObjects, frmTemplateObjects.cboObjects.Items);
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
2661	procedure TfrmTemplateEditor.FormClose(Sender: TObject;
2662	var Action: TCloseAction);
2663	begin
2664	SaveUserBounds(Self);
2665	end;
2666
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
2700	if pnlBoilerplate.Visible and pnlGroupBP.Visible then
2701	tmplEditorSplitterBoil := reBoil.Height;
2702	if pnlNotes.Visible then
2703	tmplEditorSplitterNotes := pnlNotes.Height;
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
3143	pnlMenu.Width := mbMain.Width + 4;
3144	mbMain.Width := pnlMenu.Width - 3;
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;
3218	GetAutoGenText(AName, AText, uPersonalObjects); // -------- CQ #8665 - RV ------------
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;
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;
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);
3441	FastAssign(ExportTemplateFields(Flds), Flds);
3442	for i := 0 to Flds.Count-1 do
3443	Flds[i] := ' ' + Flds[i];
3444	FastAddStrings(Flds, Tmpl);
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;
3748	ShowMsg('Can not assign a Reminder Dialog to a Reason for Request');
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
3834	(*procedure TfrmTemplateEditor.UpdatePersonalObjects;
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;
3847	end;*)
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)]);
3919	ShowMsg(Format(TemplateLockedText, [TTemplate(Sender).PrintName]));
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
4118	ltTitle: FastAssign(SubSetOfAllTitles(StartFrom, Direction), tmpSL);
4119	// ltConsult:
4120	ltProcedure:
4121	begin
4122	FastAssign(SubSetOfProcedures(StartFrom, Direction), tmpSL);
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;
4140	update: boolean;
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
4149	update := true;
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
4155	ShowMsg(GetLinkName(cbxLink.ItemID, TTemplateLinkType(pnlLink.tag)) +
4156	' is already assigned to another template.');
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);
4165	end;
4166	end
4167	else
4168	Template.FileLink := '';
4169	if update then
4170	UpdateApply(Template);
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: