?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Initial import of Scalos. To decrease size I have
[AROS-Contrib.git] / scalos / Plugins / Prefs / Menu / MenuPrefs.c
blob2f9acc3f2128eed1883365cb5214fd49b7a00e42
1 // MenuPrefs.c
2 // $Date$
3 // $Revision$
4
5 #ifdef __AROS__
6 #define MUIMASTER_YES_INLINE_STDARG
7 #endif
8
9 #include <stdlib.h>
10 #include <string.h>
11 #include <stdio.h>
12 #include <stddef.h>
13 #include <ctype.h>
14 #include <dos/dos.h>
15 #include <exec/types.h>
16 #include <exec/memory.h>
17 #include <libraries/dos.h>
18 #include <libraries/dosextens.h>
19 #include <libraries/gadtools.h>
20 #include <libraries/asl.h>
21 #include <libraries/mui.h>
22 #include <libraries/iffparse.h>
23 #include <devices/clipboard.h>
24 #include <utility/utility.h>
25 #include <workbench/workbench.h>
26 #include <workbench/icon.h>
27 #include <intuition/intuition.h>
28 #include <intuition/classusr.h>
29 #include <graphics/gfxmacros.h>
30 #include <prefs/prefhdr.h>
31
32 #include <clib/alib_protos.h>
33
34 #define __USE_SYSBASE
35
36 #include <proto/exec.h>
37 #include <proto/dos.h>
38 #include <proto/icon.h>
39 #include <proto/graphics.h>
40 #include <proto/intuition.h>
41 #include <proto/gadtools.h>
42 #include <proto/utility.h>
43 #include <proto/asl.h>
44 #include <proto/locale.h>
45 #include <proto/iffparse.h>
46
47 #ifndef __AROS__
48 #define NO_INLINE_STDARG
49 #endif
50
51 #include <proto/muimaster.h>
52
53 #include <mui/NListview_mcc.h>
54 #include <mui/NListtree_mcc.h>
55 #include <mui/Lamp_mcc.h>
56 #include <scalos/scalosprefsplugin.h>
57 #include <scalos/scalosmenuprefsplugin.h>
58 #include <defs.h>
59 #include <Year.h>
60
61 #include "MenuPrefs.h"
62 #include "DataTypesMCC.h"
63
64 #define ScalosMenu_NUMBERS
65 #define ScalosMenu_ARRAY
66 #define ScalosMenu_CODE
67 #include STR(SCALOSLOCALE)
68
69 #include "plugin.h"
70
71 //----------------------------------------------------------------------------
72
73 #ifdef __AROS__
74 #define myNListTreeObject BOOPSIOBJMACRO_START(myNListTreeClass->mcc_Class)
75 //#define myNListObject BOOPSIOBJMACRO_START(myNListClass->mcc_Class)
76 //#define myFileTypesNListTreeObject BOOPSIOBJMACRO_START(myFileTypesNListTreeClass->mcc_Class)
77 #else
78 #define myNListTreeObject NewObject(myNListTreeClass->mcc_Class, 0
79 #define myNListObject NewObject(myNListClass->mcc_Class, 0
80 #define myFileTypesNListTreeObject NewObject(myFileTypesNListTreeClass->mcc_Class, 0
81 #define myFileTypesActionsNListObject NewObject(myFileTypesActionsNListClass->mcc_Class, 0
82 #endif
83
84 //----------------------------------------------------------------------------
85
86 // Intuition limits for various menu entries
87 #define MAX_MENU (NOMENU + 1)
88 #define MAX_MENUITEM (NOITEM + 1)
89 #define MAX_SUBITEM (NOSUB + 1)
90
91
92 //----------------------------------------------------------------------------
93
94 #define IMG(prefix1,PREFIX2) \
95 BodychunkObject,\
96 MUIA_FixWidth , PREFIX2##_WIDTH ,\
97 MUIA_FixHeight , PREFIX2##_HEIGHT,\
98 MUIA_Bitmap_Width , PREFIX2##_WIDTH ,\
99 MUIA_Bitmap_Height , PREFIX2##_HEIGHT,\
100 MUIA_Bodychunk_Depth , PREFIX2##_DEPTH ,\
101 MUIA_Bodychunk_Body , (UBYTE *) prefix1##_body,\
102 MUIA_Bodychunk_Compression, PREFIX2##_COMPRESSION,\
103 MUIA_Bodychunk_Masking , PREFIX2##_MASKING,\
104 MUIA_Bitmap_SourceColors , (ULONG *) prefix1##_colors,\
105 MUIA_Bitmap_Transparent , 0,\
106 End
107
108 //----------------------------------------------------------------------------
109
110 // defined in DefaultMenu.c
111
112 extern const struct DefaultMenuEntry DefaultMenu[];
113 extern const ULONG DefaultMenuEntries;
114
115 //----------------------------------------------------------------------------
116
117 // local data structures
118
119 #define KeyButtonHelp(name,key,HelpText)\
120 TextObject,\
121 ButtonFrame,\
122 MUIA_CycleChain, TRUE, \
123 MUIA_Font, MUIV_Font_Button,\
124 MUIA_Text_Contents, (name),\
125 MUIA_Text_PreParse, "\33c",\
126 MUIA_Text_HiChar , (key),\
127 MUIA_ControlChar , (key),\
128 MUIA_InputMode , MUIV_InputMode_RelVerify,\
129 MUIA_Background , MUII_ButtonBack,\
130 MUIA_ShortHelp, HelpText,\
131 End
132
133
134 #define Application_Return_EDIT 0
135 #define Application_Return_USE 1001
136 #define Application_Return_SAVE 1002
137
138 #define ID_MENU MAKE_ID('M','E','N','U')
139
140 #define MAX_LINESIZE 500 // maximum length for command strings
141 #define MAX_NAMESIZE 100 // maximum length for menu names
142 #define MAX_COMMANDNAME 300 // maximum length for command names
143
144 struct MenuListEntry
145 {
146 char llist_HotKey[2];
147 UBYTE llist_EntryType;
148 UBYTE llist_Flags;
149 UBYTE llist_CommandType;
150 UBYTE llist_CommandFlags;
151 BYTE llist_Priority;
152 ULONG llist_Stack;
153 Object *llist_UnSelImageObj; // Popup menu image
154 ULONG llist_UnSelImageIndex;
155 char llist_name[MAX_LINESIZE];
156 char llist_UnselectedIconName[MAX_COMMANDNAME];
157 char llist_SelectedIconName[MAX_COMMANDNAME];
158 char llist_MenuItemName[MAX_NAMESIZE + 10];
159 };
160
161 struct MenuInsertEntry
162 {
163 struct ScalosMenuTree *mie_TreeEntry;
164 ULONG mie_MenuFlags;
165 };
166
167 // values in llist_Flags
168 #define LLISTFLGB_NotRemovable 0
169 #define LLISTFLGB_NameNotSetable 1
170 #define LLISTFLGB_MayNotHaveChildren 2
171 #define LLISTFLGB_PopupMenu 3
172 #define LLISTFLGF_NotRemovable (1 << LLISTFLGB_NotRemovable)
173 #define LLISTFLGF_NameNotSetable (1 << LLISTFLGB_NameNotSetable)
174 #define LLISTFLGF_MayNotHaveChildren (1 << LLISTFLGB_MayNotHaveChildren)
175 #define LLISTFLGF_PopupMenu (1 << LLISTFLGB_PopupMenu)
176
177
178 enum ScalosMenuChunkId
179 {
180 SCMID_MainMenu = 0,
181 SCMID_Popup_Disk,
182 SCMID_Popup_Drawer,
183 SCMID_Popup_Tool,
184 SCMID_Popup_Trashcan,
185 SCMID_Popup_Window,
186 SCMID_Popup_AppIcon,
187 SCMID_Popup_Desktop,
188 };
189
190 struct ScalosMenuChunk
191 {
192 UWORD smch_MenuID; // enum ScalosMenuChunkId
193 UWORD smch_Entries; // number of entries
194 struct ScalosMenuTree smch_Menu[1]; // (variable) the menu entries
195 };
196
197 struct CommandTableEntry
198 {
199 CONST_STRPTR cte_Command;
200 ULONG cte_NameMsgId;
201 };
202
203 enum MenuEntryType
204 {
205 MENUENTRY_Menu,
206 MENUENTRY_MenuItem,
207 MENUENTRY_SubItem,
208 MENUENTRY_Invalid,
209 };
210
211 //----------------------------------------------------------------------------
212
213 // aus mempools.lib
214 #ifndef __amigaos4__
215 extern int _STI_240_InitMemFunctions(void);
216 extern void _STD_240_TerminateMemFunctions(void);
217 #endif
218
219 //----------------------------------------------------------------------------
220
221 // local functions
222
223 static BOOL OpenLibraries(void);
224 static void CloseLibraries(void);
225
226 DISPATCHER_PROTO(MenuPrefs);
227 static Object *CreatePrefsGroup(struct MenuPrefsInst *inst);
228
229 static SAVEDS(APTR) INTERRUPT CmdListConstructHookFunc(struct Hook *hook, APTR obj, struct NList_ConstructMessage *msg);
230 static SAVEDS(void) INTERRUPT CmdListDestructHookFunc(struct Hook *hook, APTR obj, struct NList_DestructMessage *msg);
231 static SAVEDS(ULONG) INTERRUPT CmdListDisplayHookFunc(struct Hook *hook, APTR obj, struct NList_DisplayMessage *ltdm);
232 static SAVEDS(LONG) INTERRUPT CmdListCompareHookFunc(struct Hook *hook, Object *obj, struct NList_CompareMessage *msg);
233 static SAVEDS(LONG) INTERRUPT CmdListPopupOpenHookFunc(struct Hook *hook, Object *list, Object *str);
234
235 static SAVEDS(APTR) INTERRUPT TreeConstructFunc(struct Hook *hook, APTR obj, struct MUIP_NListtree_ConstructMessage *ltcm);
236 static SAVEDS(void) INTERRUPT TreeDestructFunc(struct Hook *hook, APTR obj, struct MUIP_NListtree_DestructMessage *ltdm);
237 static SAVEDS(ULONG) INTERRUPT TreeDisplayFunc(struct Hook *hook, APTR obj, struct MUIP_NListtree_DisplayMessage *ltdm);
238
239 static SAVEDS(ULONG) INTERRUPT ImagePopAslFileStartHookFunc(struct Hook *hook, Object *o, Msg msg);
240
241 static STRPTR GetLocString(ULONG MsgId);
242 static void TranslateStringArray(STRPTR *stringArray);
243 static void TranslateNewMenu(struct NewMenu *nm);
244
245 static SAVEDS(APTR) INTERRUPT ResetToDefaultsHookFunc(struct Hook *hook, Object *o, Msg msg);
246 static SAVEDS(APTR) INTERRUPT OpenHookFunc(struct Hook *hook, Object *o, Msg msg);
247 static SAVEDS(APTR) INTERRUPT SaveAsHookFunc(struct Hook *hook, Object *o, Msg msg);
248 static SAVEDS(APTR) INTERRUPT AboutHookFunc(struct Hook *hook, Object *o, Msg msg);
249 static SAVEDS(APTR) INTERRUPT LastSavedHookFunc(struct Hook *hook, Object *o, Msg msg);
250 static SAVEDS(APTR) INTERRUPT RestoreHookFunc(struct Hook *hook, Object *o, Msg msg);
251 static SAVEDS(APTR) INTERRUPT MergeHookFunc(struct Hook *hook, Object *o, Msg msg);
252 static SAVEDS(APTR) INTERRUPT ImportTDHookFunc(struct Hook *hook, Object *o, Msg msg);
253 static SAVEDS(APTR) INTERRUPT ImportPHookFunc(struct Hook *hook, Object *o, Msg msg);
254
255 static SAVEDS(APTR) INTERRUPT RenameEntryHookFunc(struct Hook *hook, Object *o, Msg msg);
256 static SAVEDS(APTR) INTERRUPT ChangeEntry3HookFunc(struct Hook *hook, Object *o, Msg msg);
257 static SAVEDS(APTR) INTERRUPT ChangeUnselectedImageHookFunc(struct Hook *hook, Object *o, Msg msg);
258 static SAVEDS(APTR) INTERRUPT ChangeSelectedImageHookFunc(struct Hook *hook, Object *o, Msg msg);
259
260 static SAVEDS(APTR) INTERRUPT ChangeHotkeyHookFunc(struct Hook *hook, Object *o, Msg msg);
261 static SAVEDS(APTR) INTERRUPT SelectEntryHookFunc(struct Hook *hook, Object *o, Msg msg);
262 static SAVEDS(APTR) INTERRUPT PopButtonHookFunc(struct Hook *hook, Object *o, Msg msg);
263 static SAVEDS(APTR) INTERRUPT AddMenuHookFunc(struct Hook *hook, Object *o, Msg msg);
264 static SAVEDS(APTR) INTERRUPT AddCommandHookFunc(struct Hook *hook, Object *o, Msg msg);
265 static SAVEDS(APTR) INTERRUPT AddMenuItemHookFunc(struct Hook *hook, Object *o, Msg msg);
266 static SAVEDS(APTR) INTERRUPT RemoveEntryHookFunc(struct Hook *hook, Object *o, Msg msg);
267 static SAVEDS(APTR) INTERRUPT CollapseSelectedHookFunc(struct Hook *hook, Object *o, Msg msg);
268 static SAVEDS(APTR) INTERRUPT ExpandSelectedHookFunc(struct Hook *hook, Object *o, Msg msg);
269 static SAVEDS(APTR) INTERRUPT CollapseAllHookFunc(struct Hook *hook, Object *o, Msg msg);
270 static SAVEDS(APTR) INTERRUPT ExpandAllHookFunc(struct Hook *hook, Object *o, Msg msg);
271 static SAVEDS(APTR) INTERRUPT CmdSelectedHookFunc(struct Hook *hook, Object *o, Msg msg);
272 static SAVEDS(APTR) INTERRUPT ContextMenuTriggerHookFunc(struct Hook *hook, Object *o, Msg msg);
273 static SAVEDS(APTR) INTERRUPT AppMessageHookFunc(struct Hook *hook, Object *o, Msg msg);
274 static SAVEDS(APTR) INTERRUPT SettingsChangedHookFunc(struct Hook *hook, Object *o, Msg msg);
275 static SAVEDS(void) INTERRUPT AslIntuiMsgHookFunc(struct Hook *hook, Object *o, Msg msg);
276 static SAVEDS(void) INTERRUPT HideObsoleteHookFunc(struct Hook *hook, Object *o, Msg msg);
277
278 static SAVEDS(void) INTERRUPT MenuCopyHookFunc(struct Hook *hook, Object *o, Msg msg);
279 static SAVEDS(void) INTERRUPT MenuCutHookFunc(struct Hook *hook, Object *o, Msg msg);
280 static SAVEDS(void) INTERRUPT MenuPasteHookFunc(struct Hook *hook, Object *o, Msg msg);
281
282 static struct MUI_NListtree_TreeNode *MoveMenuTree(struct MenuPrefsInst *inst,
283 ULONG DestListtreeIndex, ULONG SrcListtreeIndex, ULONG EntryIndex);
284 static struct MUI_NListtree_TreeNode *CopyFileTypesEntry(struct MenuPrefsInst *inst,
285 struct MUI_NListtree_TreeNode *tnToListNode, struct MUI_NListtree_TreeNode *tnToPrevNode,
286 struct MUI_NListtree_TreeNode *tnFrom, ULONG destList, ULONG srcList);
287 static LONG CopyMenuTree(struct MenuPrefsInst *inst,
288 Object *ListTreeDest, Object *ListTreeSrc,
289 struct MUI_NListtree_TreeNode *Src, struct MUI_NListtree_TreeNode *DestParent);
290 static struct MUI_NListtree_TreeNode *CopyMenuEntry(struct MenuPrefsInst *inst,
291 Object *ListTreeDest, Object *ListTreeSrc,
292 struct MUI_NListtree_TreeNode *Src, struct MUI_NListtree_TreeNode *DestParent);
293 static LONG ReadPrefsFile(struct MenuPrefsInst *inst, CONST_STRPTR Filename, BOOL Quiet);
294 static LONG WritePrefsFile(struct MenuPrefsInst *inst, CONST_STRPTR Filename);
295 static LONG SaveMenuNode(struct MenuPrefsInst *inst, struct IFFHandle *iff,
296 const struct MenuPrefsPopMenuNode *TreeNode, enum ScalosMenuChunkId ChunkID);
297 static UWORD CountMenuEntries(struct MenuPrefsInst *inst, Object *ListTree,
298 const struct MUI_NListtree_TreeNode *TreeNode, size_t *StringSpace);
299 static LONG BuildMenuTree(struct MenuPrefsInst *inst, Object *ListTree,
300 const struct MUI_NListtree_TreeNode *TreeNode,
301 struct ScalosMenuTree **MenuSpace, STRPTR *StringSpace,
302 struct ScalosMenuTree **Parent);
303 static void RemoveAddresses(struct ScalosMenuTree *MenuTree, const UBYTE *baseAddr);
304 static LONG SaveIcon(struct MenuPrefsInst *inst, CONST_STRPTR IconName);
305 static void ClearMenuList(struct MenuPrefsInst *inst);
306 static STRPTR AddMenuString(CONST_STRPTR MenuString, STRPTR *StringSpace);
307 static void AddAddresses(struct ScalosMenuTree *MenuTree, const UBYTE *BaseAddr);
308 static void GenerateMenuList(struct MenuPrefsInst *inst, struct ScalosMenuTree *mTree,
309 Object *ListTree, struct MUI_NListtree_TreeNode *MenuNode);
310 static BOOL RequestTdFile(struct MenuPrefsInst *inst, char *FileName, size_t MaxLen);
311 static BOOL RequestParmFile(struct MenuPrefsInst *inst, char *FileName, size_t MaxLen);
312 static BOOL CmpWord(CONST_STRPTR Cmd, CONST_STRPTR Line);
313 static void StripLF(STRPTR Line);
314 static STRPTR NextWord(STRPTR lp);
315 static void CopyWord(STRPTR dest, CONST_STRPTR src, size_t MaxLen);
316 static struct MUI_NListtree_TreeNode *AppMessage_Menu(struct MenuPrefsInst *inst,
317 struct MUI_NListtree_TreeNode **TreeNode,
318 struct MUI_NListtree_TreeNode **ParentNode, const struct WBArg *wbArg,
319 CONST_STRPTR Path, CONST_STRPTR FileName);
320 static void EnableCommandArgumentGadgets(struct MenuPrefsInst *inst, const struct MenuListEntry *mle);
321 static BOOL IsPopupMenu(struct MenuPrefsInst *inst, struct MUI_NListtree_TreeNode *TreeNode);
322 static enum MenuEntryType GetMenuEntryType(struct MenuPrefsInst *inst,
323 struct MUI_NListtree_TreeNode *TreeNode);
324 static ULONG GetMaxCountForEntry(enum MenuEntryType type);
325 static void SwitchPopButton(struct MenuPrefsInst *inst, UBYTE CommandType);
326 DISPATCHER_PROTO(myNListTree);
327 static Object *CreatePrefsImage(void);
328 static void InitHooks(struct MenuPrefsInst *inst);
329 static void SetChangedFlag(struct MenuPrefsInst *inst, BOOL changed);
330 static void AddDefaultMenuContents(struct MenuPrefsInst *inst);
331 static void ParseToolTypes(struct MenuPrefsInst *inst, struct MUIP_ScalosPrefs_ParseToolTypes *ptt);
332 static void InsertMenuRootEntries(struct MenuPrefsInst *inst);
333 static Object *GetMenuEntryListtree(struct MenuPrefsInst *inst);
334 static struct MUI_NListtree_TreeNode *GetParentNodeForMenu(struct MenuPrefsInst *inst, struct MUI_NListtree_TreeNode **PrevNode);
335 static struct MUI_NListtree_TreeNode *GetParentNodeForMenuItem(struct MenuPrefsInst *inst, struct MUI_NListtree_TreeNode **PrevNode);
336 static BOOL MayPasteOnto(struct MenuPrefsInst *inst,
337 struct MUI_NListtree_TreeNode *tnTo, struct MUI_NListtree_TreeNode *tnFrom);
338 static struct MUI_NListtree_TreeNode *MayPasteBelow(struct MenuPrefsInst *inst,
339 struct MUI_NListtree_TreeNode *tnTo, struct MUI_NListtree_TreeNode *tnFrom);
340 #if !defined(__SASC) && !defined(__MORPHOS__) && !defined(__AROS__)
341 static char *stpblk(const char *q);
342 #if !defined(__amigaos4__)
343 static size_t stccpy(char *dest, const char *src, size_t MaxLen);
344 #endif /* !defined(__amigaos4__) */
345 #endif /* !defined(__SASC) && !defined(__MORPHOS__) */
346
347 //----------------------------------------------------------------------------
348
349 // local data items
350
351 struct Library *MUIMasterBase;
352 T_LOCALEBASE LocaleBase;
353 struct GfxBase *GfxBase;
354 struct Library *IconBase;
355 struct Library *IFFParseBase;
356 T_UTILITYBASE UtilityBase;
357 struct IntuitionBase *IntuitionBase;
358 struct Library *DataTypesBase;
359
360 #ifdef __amigaos4__
361 struct Library *DOSBase;
362 struct DOSIFace *IDOS;
363 struct LocaleIFace *ILocale;
364 struct MUIMasterIFace *IMUIMaster;
365 struct GraphicsIFace *IGraphics;
366 struct IconIFace *IIcon;
367 struct IFFParseIFace *IIFFParse;
368 struct DataTypesIFace *IDataTypes;
369 struct UtilityIFace *IUtility;
370 struct IntuitionIFace *IIntuition;
371 struct Library *NewlibBase;
372 struct Interface *INewlib;
373 #endif
374
375 #ifdef __AROS__
376 struct DosLibrary *DOSBase;
377 #endif
378
379 static BOOL StaticsTranslated;
380
381 static ULONG MajorVersion, MinorVersion;
382
383 static const struct MUIP_ScalosPrefs_MCCList RequiredMccList[] =
384 {
385 { MUIC_Lamp, 11, 1 },
386 { MUIC_NListtree, 18, 18 },
387 { MUIC_NListview, 18, 0 },
388 { NULL, 0, 0 }
389 };
390
391 static const struct Hook MenuPrefsHooks[] =
392 {
393 { { NULL, NULL }, HOOKFUNC_DEF(TreeConstructFunc), NULL },
394 { { NULL, NULL }, HOOKFUNC_DEF(TreeDestructFunc), NULL },
395 { { NULL, NULL }, HOOKFUNC_DEF(TreeDisplayFunc), NULL },
396
397 { { NULL, NULL }, HOOKFUNC_DEF(CmdListConstructHookFunc), NULL },
398 { { NULL, NULL }, HOOKFUNC_DEF(CmdListDestructHookFunc), NULL },
399 { { NULL, NULL }, HOOKFUNC_DEF(CmdListDisplayHookFunc), },
400 { { NULL, NULL }, HOOKFUNC_DEF(CmdListCompareHookFunc), NULL },
401 { { NULL, NULL }, HOOKFUNC_DEF(CmdListPopupOpenHookFunc), NULL },
402
403 { { NULL, NULL }, HOOKFUNC_DEF(ImagePopAslFileStartHookFunc), NULL },
404
405 { { NULL, NULL }, HOOKFUNC_DEF(ResetToDefaultsHookFunc), NULL },
406 { { NULL, NULL }, HOOKFUNC_DEF(OpenHookFunc), NULL },
407 { { NULL, NULL }, HOOKFUNC_DEF(LastSavedHookFunc), NULL },
408 { { NULL, NULL }, HOOKFUNC_DEF(RestoreHookFunc), NULL },
409 { { NULL, NULL }, HOOKFUNC_DEF(SaveAsHookFunc), NULL },
410 { { NULL, NULL }, HOOKFUNC_DEF(MergeHookFunc), NULL },
411 { { NULL, NULL }, HOOKFUNC_DEF(ImportTDHookFunc), NULL },
412 { { NULL, NULL }, HOOKFUNC_DEF(ImportPHookFunc), NULL },
413 { { NULL, NULL }, HOOKFUNC_DEF(RenameEntryHookFunc), NULL },
414 { { NULL, NULL }, HOOKFUNC_DEF(ChangeHotkeyHookFunc), NULL },
415 { { NULL, NULL }, HOOKFUNC_DEF(ChangeEntry3HookFunc), NULL },
416 { { NULL, NULL }, HOOKFUNC_DEF(ChangeUnselectedImageHookFunc), NULL },
417 { { NULL, NULL }, HOOKFUNC_DEF(ChangeSelectedImageHookFunc), NULL },
418 { { NULL, NULL }, HOOKFUNC_DEF(SelectEntryHookFunc), NULL },
419 { { NULL, NULL }, HOOKFUNC_DEF(PopButtonHookFunc), NULL },
420 { { NULL, NULL }, HOOKFUNC_DEF(AddMenuHookFunc), NULL },
421 { { NULL, NULL }, HOOKFUNC_DEF(AddCommandHookFunc), NULL },
422 { { NULL, NULL }, HOOKFUNC_DEF(AddMenuItemHookFunc), NULL },
423 { { NULL, NULL }, HOOKFUNC_DEF(RemoveEntryHookFunc), NULL },
424 { { NULL, NULL }, HOOKFUNC_DEF(AboutHookFunc), NULL },
425 { { NULL, NULL }, HOOKFUNC_DEF(CollapseSelectedHookFunc), NULL },
426 { { NULL, NULL }, HOOKFUNC_DEF(ExpandSelectedHookFunc), NULL },
427 { { NULL, NULL }, HOOKFUNC_DEF(CollapseAllHookFunc), NULL },
428 { { NULL, NULL }, HOOKFUNC_DEF(ExpandAllHookFunc), NULL },
429 { { NULL, NULL }, HOOKFUNC_DEF(CmdSelectedHookFunc), NULL },
430 { { NULL, NULL }, HOOKFUNC_DEF(ContextMenuTriggerHookFunc), NULL },
431 { { NULL, NULL }, HOOKFUNC_DEF(AppMessageHookFunc), NULL },
432 { { NULL, NULL }, HOOKFUNC_DEF(SettingsChangedHookFunc), NULL },
433 { { NULL, NULL }, HOOKFUNC_DEF(AslIntuiMsgHookFunc), NULL },
434 { { NULL, NULL }, HOOKFUNC_DEF(HideObsoleteHookFunc), NULL },
435
436 { { NULL, NULL }, HOOKFUNC_DEF(MenuCopyHookFunc), NULL },
437 { { NULL, NULL }, HOOKFUNC_DEF(MenuCutHookFunc), NULL },
438 { { NULL, NULL }, HOOKFUNC_DEF(MenuPasteHookFunc), NULL },
439 };
440
441 static struct Locale *MenuPrefsLocale;
442 static struct Catalog *MenuPrefsCatalog;
443
444 struct MUI_CustomClass *MenuPrefsClass;
445 struct MUI_CustomClass *myNListTreeClass;
446 struct MUI_CustomClass *DataTypesImageClass;
447
448 static STRPTR CmdModeStrings[] =
449 {
450 (STRPTR) MSGID_COMMANDNAME,
451 (STRPTR) MSGID_WBNAME,
452 (STRPTR) MSGID_ADOSNAME,
453 (STRPTR) MSGID_ICONWINNAME,
454 (STRPTR) MSGID_AREXXNAME,
455 (STRPTR) MSGID_PLUGINNAME,
456 NULL
457 };
458
459 struct CommandTableEntry CommandsTable[] =
460 {
461 { "about", MSGID_COM5NAME },
462 { "backdrop", MSGID_COM1NAME },
463 { "cleanup", MSGID_COM12NAME },
464 { "cleanupbydate", MSGID_COM44NAME },
465 { "cleanupbyname", MSGID_COM43NAME },
466 { "cleanupbysize", MSGID_COM45NAME },
467 { "cleanupbytype", MSGID_COM46NAME },
468 { "clearselection", MSGID_COM36NAME },
469 { "clone", MSGID_COM28NAME },
470 { "close", MSGID_COM9NAME },
471 { "copy", MSGID_COM39NAME },
472 { "copyto", MSGID_COM49NAME },
473 { "createthumbnail", MSGID_COM51NAME },
474 { "cut", MSGID_COM40NAME },
475 { "delete", MSGID_COM27NAME },
476 { "emptytrashcan", MSGID_COM29NAME },
477 { "executecommand", MSGID_COM2NAME },
478 { "find", MSGID_COM_FIND },
479 { "formatdisk", MSGID_COM33NAME },
480 { "iconify", MSGID_COM32NAME },
481 { "iconinfo", MSGID_COM22NAME },
482 { "iconproperties", MSGID_COM_ICONPROPERTIES },
483 { "lastmsg", MSGID_COM30NAME },
484 { "leaveout", MSGID_COM25NAME },
485 { "makedir", MSGID_COM7NAME },
486 { "moveto", MSGID_COM50NAME },
487 { "open", MSGID_COM19NAME },
488 { "openinbrowserwindow", MSGID_COM_OPENBROWSERWINDOW },
489 { "openinnewwindow", MSGID_COM_OPENNEWWINDOW },
490 { "parent", MSGID_COM8NAME },
491 { "paste", MSGID_COM41NAME },
492 { "putaway", MSGID_COM26NAME },
493 { "quit", MSGID_COM6NAME },
494 { "redo", MSGID_COM_REDO },
495 { "redraw", MSGID_COM31NAME },
496 { "redrawall", MSGID_COM3NAME },
497 { "rename", MSGID_COM21NAME },
498 { "reset", MSGID_COM20NAME },
499 { "selectall", MSGID_COM11NAME },
500 { "showallfiles", MSGID_COM16NAME },
501 { "showdefault", MSGID_COM48NAME },
502 { "showonlyicons", MSGID_COM15NAME },
503 { "shutdown", MSGID_COM34NAME },
504 { "sizetofit", MSGID_COM35NAME },
505 { "snapshot", MSGID_COM23NAME },
506 { "snapshotall", MSGID_COM14NAME },
507 { "snapshotwindow", MSGID_COM13NAME },
508 { "thumbnailcachecleanup", MSGID_COM_THUMBNAILCACHECLEANUP },
509 { "undo", MSGID_COM_UNDO },
510 { "unsnapshot", MSGID_COM24NAME },
511 { "update", MSGID_COM10NAME },
512 { "updateall", MSGID_COM4NAME },
513 { "viewbydate", MSGID_COM38NAME },
514 { "viewbydefault", MSGID_COM47NAME },
515 { "viewbyicon", MSGID_COM17NAME },
516 { "viewbysize", MSGID_COM37NAME },
517 { "viewbytext", MSGID_COM18NAME },
518 { "viewbytype", MSGID_COM42NAME },
519 { "windowproperties", MSGID_COM_WINDOWPROPERTIES },
520 };
521
522 struct CommandTableEntry *CommandsArray[1 + Sizeof(CommandsTable)];
523
524 static struct NewMenu ContextMenus[] =
525 {
526 { NM_TITLE, (STRPTR) MSGID_TITLENAME, NULL, 0, 0, NULL },
527 { NM_ITEM, (STRPTR) MSGID_MENU_PROJECT_OPEN, (STRPTR) MSGID_MENU_PROJECT_OPEN_SHORT, 0, 0, (APTR) HOOKNDX_Open },
528 { NM_ITEM, (STRPTR) MSGID_MENU_PROJECT_MERGE, (STRPTR) MSGID_MENU_PROJECT_MERGE_SHORT, 0, 0, (APTR) HOOKNDX_Merge },
529 { NM_ITEM, (STRPTR) MSGID_MENU_PROJECT_SAVEAS, (STRPTR) MSGID_MENU_PROJECT_SAVEAS_SHORT, 0, 0, (APTR) HOOKNDX_SaveAs },
530 { NM_ITEM, NM_BARLABEL, NULL, 0, 0, NULL },
531 { NM_ITEM, (STRPTR) MSGID_MENU_PROJECT_IMPORT, NULL, 0, 0, NULL },
532 { NM_SUB, (STRPTR) MSGID_MENU_PROJECT_IMPORT_TD, (STRPTR) MSGID_MENU_PROJECT_IMPORT_TD_SHORT, 0, 0, (APTR) HOOKNDX_ImportTD },
533 { NM_SUB, (STRPTR) MSGID_MENU_PROJECT_IMPORT_P, (STRPTR) MSGID_MENU_PROJECT_IMPORT_P_SHORT, 0, 0, (APTR) HOOKNDX_ImportP },
534 { NM_ITEM, NM_BARLABEL, NULL, 0, 0, NULL },
535 { NM_ITEM, (STRPTR) MSGID_MENU_EDIT_COLLAPSE, NULL, NM_ITEMDISABLED, 0, (APTR) HOOKNDX_CollapseSelected },
536 { NM_ITEM, (STRPTR) MSGID_MENU_EDIT_EXPAND, NULL, NM_ITEMDISABLED, 0, (APTR) HOOKNDX_ExpandSelected },
537 { NM_ITEM, NM_BARLABEL, NULL, 0, 0, NULL },
538 { NM_ITEM, (STRPTR) MSGID_MENU_EDIT_COLLAPSEALL, NULL, 0, 0, (APTR) HOOKNDX_CollapseAll },
539 { NM_ITEM, (STRPTR) MSGID_MENU_EDIT_EXPANDALL, NULL, 0, 0, (APTR) HOOKNDX_ExpandAll },
540 { NM_ITEM, NM_BARLABEL, NULL, 0, 0, NULL },
541 { NM_ITEM, (STRPTR) MSGID_MENU_EDIT_COPY, NULL, 0, 0, (APTR) HOOKNDX_MenuCopy },
542 { NM_ITEM, (STRPTR) MSGID_MENU_EDIT_CUT, NULL, 0, 0, (APTR) HOOKNDX_MenuCut },
543 { NM_ITEM, (STRPTR) MSGID_MENU_EDIT_PASTE, NULL, NM_ITEMDISABLED, 0, (APTR) HOOKNDX_MenuPaste },
544 { NM_ITEM, NM_BARLABEL, NULL, 0, 0, NULL },
545 { NM_ITEM, (STRPTR) MSGID_MENU_SETTINGS_HIDEOBSOLETE, NULL, CHECKIT|MENUTOGGLE, 0, (APTR) HOOKNDX_HideObsolete },
546 { NM_ITEM, NM_BARLABEL, NULL, 0, 0, NULL },
547 { NM_ITEM, (STRPTR) MSGID_MENU_PROJECT_ABOUT, NULL, 0, 0, (APTR) HOOKNDX_About },
548
549 { NM_END, NULL, NULL, 0, 0, 0,},
550 };
551
552 static const LONG StopChunkList[] =
553 {
554 ID_PREF, ID_MENU,
555 };
556
557 #define ENTRYTYPE_MAX (1 + SCAMENUTYPE_ToolsMenu)
558
559 // dest source
560 static const BOOL MayPasteAfterMatrix[ENTRYTYPE_MAX][ENTRYTYPE_MAX] =
561 {
562 // 0 1 2 3 4
563 /* 0 SCAMENUTYPE_MainMenu */
564 { FALSE, FALSE, FALSE, FALSE, FALSE, },
565 /* 1 SCAMENUTYPE_Menu */
566 { FALSE, TRUE, TRUE, FALSE, TRUE, },
567 /* 2 SCAMENUTYPE_MenuItem */
568 { FALSE, TRUE, TRUE, TRUE, FALSE, },
569 /* 3 SCAMENUTYPE_Command */
570 { FALSE, FALSE, FALSE, TRUE, FALSE, },
571 /* 4 SCAMENUTYPE_ToolsMenu */
572 { FALSE, TRUE, FALSE, FALSE, FALSE, },
573 // 0 1 2 3 4
574 };
575 // dest source
576 static const BOOL MayPasteIntoMatrix[ENTRYTYPE_MAX][ENTRYTYPE_MAX] =
577 {
578 // 0 1 2 3 4
579 /* 0 SCAMENUTYPE_MainMenu */
580 { FALSE, TRUE, FALSE, FALSE, FALSE, },
581 /* 1 SCAMENUTYPE_Menu */
582 { FALSE, TRUE, TRUE, FALSE, FALSE, },
583 /* 2 SCAMENUTYPE_MenuItem */
584 { FALSE, FALSE, FALSE, TRUE, FALSE, },
585 /* 3 SCAMENUTYPE_Command */
586 { FALSE, FALSE, FALSE, TRUE, FALSE, },
587 /* 4 SCAMENUTYPE_ToolsMenu */
588 { FALSE, TRUE, TRUE, FALSE, FALSE, },
589 // 0 1 2 3 4
590 };
591 //----------------------------------------------------------------------------
592
593 void closePlugin(struct PluginBase *PluginBase)
594 {
595 d1(kprintf("%s/%s/%ld: start\n", __FILE__, __FUNC__, __LINE__));
596
597 if (DataTypesImageClass)
598 {
599 CleanupDtpicClass(DataTypesImageClass);
600 DataTypesImageClass = NULL;
601 }
602 if (myNListTreeClass)
603 {
604 MUI_DeleteCustomClass(myNListTreeClass);
605 myNListTreeClass = NULL;
606 }
607 if (MenuPrefsCatalog)
608 {
609 CloseCatalog(MenuPrefsCatalog);
610 MenuPrefsCatalog = NULL;
611 }
612 if (MenuPrefsLocale)
613 {
614 CloseLocale(MenuPrefsLocale);
615 MenuPrefsLocale = NULL;
616 }
617
618 if (MenuPrefsClass)
619 {
620 MUI_DeleteCustomClass(MenuPrefsClass);
621 MenuPrefsClass = NULL;
622 }
623
624 CloseLibraries();
625
626 d1(kprintf("%s/%s//%ld:\n", __FILE__, __FUNC__, __LINE__));
627
628 #if !defined(__amigaos4__) && !defined(__AROS__)
629 _STD_240_TerminateMemFunctions();
630 #endif
631
632 d1(kprintf("%s/%s//%ld: endt\n", __FILE__, __FUNC__, __LINE__));
633 }
634
635
636 LIBFUNC_P2(ULONG, LIBSCAGetPrefsInfo,
637 D0, ULONG, which,
638 A6, struct PluginBase *, PluginBase);
639 {
640 ULONG result;
641
642 d1(kprintf("%s/%s/%ld: which=%ld\n", __FILE__, __FUNC__, __LINE__, which));
643
644 (void) PluginBase;
645
646 switch(which)
647 {
648 case SCAPREFSINFO_GetClass:
649 result = (ULONG) MenuPrefsClass;
650 break;
651
652 case SCAPREFSINFO_GetTitle:
653 result = (ULONG) GetLocString(MSGID_PLUGIN_LIST_TITLE);
654 break;
655
656 case SCAPREFSINFO_GetTitleImage:
657 result = (ULONG) CreatePrefsImage();
658 break;
659
660 default:
661 result = (ULONG) NULL;
662 break;
663 }
664
665 d1(kprintf("%s/%s/%ld: result=%lu\n", __FILE__, __FUNC__, __LINE__, result));
666
667 return result;
668 }
669 LIBFUNC_END
670
671 //----------------------------------------------------------------------------
672
673 DISPATCHER(MenuPrefs)
674 {
675 struct MenuPrefsInst *inst;
676 ULONG result = 0;
677
678 switch(msg->MethodID)
679 {
680 case OM_NEW:
681 obj = (Object *) DoSuperMethodA(cl, obj, msg);
682 d1(kprintf("%s/%s/%ld: OM_NEW obj=%08lx\n", __FILE__, __FUNC__, __LINE__, obj));
683 if (obj)
684 {
685 Object *prefsobject;
686 struct opSet *ops = (struct opSet *) msg;
687
688 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
689
690 memset(inst, 0, sizeof(struct MenuPrefsInst));
691
692 inst->mpb_TreeImageIndex = 0;
693 inst->mpb_Changed = FALSE;
694 inst->mpb_WBScreen = LockPubScreen("Workbench");
695
696 InitHooks(inst);
697
698 inst->mpb_fCreateIcons = GetTagData(MUIA_ScalosPrefs_CreateIcons, TRUE, ops->ops_AttrList);
699 inst->mpb_ProgramName = (CONST_STRPTR) GetTagData(MUIA_ScalosPrefs_ProgramName, (ULONG) "", ops->ops_AttrList);
700 inst->mpb_HideObsoletePopupMenus = GetTagData(MUIM_ScalosPrefs_MenuPrefs_HideObsolete, TRUE, ops->ops_AttrList);
701 inst->mpb_Objects[OBJNDX_WIN_Main] = (APTR) GetTagData(MUIA_ScalosPrefs_MainWindow, (ULONG) NULL, ops->ops_AttrList);
702 inst->mpb_Objects[OBJNDX_APP_Main] = (APTR) GetTagData(MUIA_ScalosPrefs_Application, (ULONG) NULL, ops->ops_AttrList);
703
704 prefsobject = CreatePrefsGroup(inst);
705 d1(kprintf("%s/%s/%ld: prefsobject=%08lx\n", __FILE__, __FUNC__, __LINE__, prefsobject));
706 if (prefsobject)
707 {
708 DoMethod(obj, OM_ADDMEMBER, prefsobject);
709
710 result = (ULONG) obj;
711 }
712 else
713 {
714 CoerceMethod(cl, obj, OM_DISPOSE);
715 }
716 }
717 break;
718
719 case OM_DISPOSE:
720 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
721 d1(kprintf("%s/%s/%ld: OM_DISPOSE obj=%08lx\n", __FILE__, __FUNC__, __LINE__, obj));
722 if (inst->mpb_WBScreen)
723 {
724 UnlockPubScreen(NULL, inst->mpb_WBScreen);
725 inst->mpb_WBScreen = NULL;
726 }
727 if (inst->mpb_Objects[OBJNDX_ContextMenu])
728 {
729 MUI_DisposeObject(inst->mpb_Objects[OBJNDX_ContextMenu]);
730 inst->mpb_Objects[OBJNDX_ContextMenu] = NULL;
731 }
732 if (inst->mpb_SaveReq)
733 {
734 MUI_FreeAslRequest(inst->mpb_SaveReq);
735 inst->mpb_SaveReq = NULL;
736 }
737 if (inst->mpb_LoadReq)
738 {
739 MUI_FreeAslRequest(inst->mpb_LoadReq);
740 inst->mpb_LoadReq = NULL;
741 }
742 return DoSuperMethodA(cl, obj, msg);
743 break;
744
745 case OM_SET:
746 {
747 struct opSet *ops = (struct opSet *) msg;
748
749 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
750
751 if (FindTagItem(MUIM_ScalosPrefs_MenuPrefs_HideObsolete, ops->ops_AttrList))
752 {
753 inst->mpb_HideObsoletePopupMenus = GetTagData(MUIM_ScalosPrefs_MenuPrefs_HideObsolete, inst->mpb_HideObsoletePopupMenus, ops->ops_AttrList);
754 set(inst->mpb_Objects[OBJNDX_Menu_HideObsolete], MUIA_Menuitem_Checked, inst->mpb_HideObsoletePopupMenus);
755 CallHookPkt(&inst->mpb_Hooks[HOOKNDX_HideObsolete],
756 inst->mpb_Objects[OBJNDX_APP_Main], 0);
757 }
758 inst->mpb_fCreateIcons = GetTagData(MUIA_ScalosPrefs_CreateIcons, inst->mpb_fCreateIcons, ops->ops_AttrList);
759 inst->mpb_ProgramName = (CONST_STRPTR) GetTagData(MUIA_ScalosPrefs_ProgramName, (ULONG) inst->mpb_ProgramName, ops->ops_AttrList);
760 inst->mpb_Objects[OBJNDX_WIN_Main] = (APTR) GetTagData(MUIA_ScalosPrefs_MainWindow,
761 (ULONG) inst->mpb_Objects[OBJNDX_WIN_Main], ops->ops_AttrList);
762 inst->mpb_Objects[OBJNDX_APP_Main] = (APTR) GetTagData(MUIA_ScalosPrefs_Application,
763 (ULONG) inst->mpb_Objects[OBJNDX_APP_Main], ops->ops_AttrList);
764
765 return DoSuperMethodA(cl, obj, msg);
766 }
767 break;
768
769 case OM_GET:
770 {
771 struct opGet *opg = (struct opGet *) msg;
772
773 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
774 switch (opg->opg_AttrID)
775 {
776 case MUIA_ScalosPrefs_CreateIcons:
777 *opg->opg_Storage = inst->mpb_fCreateIcons;
778 result = 0;
779 break;
780 default:
781 result = DoSuperMethodA(cl, obj, msg);
782 }
783 }
784 break;
785
786 case MUIM_ScalosPrefs_ParseToolTypes:
787 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
788 d1(kprintf(__FILE__ "/%s/%ld: before ParseToolTypes\n", __FUNC__, __LINE__));
789 ParseToolTypes(inst, (struct MUIP_ScalosPrefs_ParseToolTypes *) msg);
790 d1(kprintf(__FILE__ "/%s/%ld: after ParseToolTypes\n", __FUNC__, __LINE__));
791 break;
792
793 case MUIM_ScalosPrefs_LoadConfig:
794 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
795 if (RETURN_OK != ReadPrefsFile(inst, "ENV:Scalos/Menu13.prefs", TRUE))
796 {
797 ClearMenuList(inst);
798 ReadPrefsFile(inst, "ENV:Scalos/Menu.prefs", FALSE);
799 }
800 SetChangedFlag(inst, FALSE);
801 break;
802
803 case MUIM_ScalosPrefs_UseConfig:
804 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
805 WritePrefsFile(inst, "ENV:Scalos/Menu13.prefs");
806 SetChangedFlag(inst, FALSE);
807 break;
808
809 case MUIM_ScalosPrefs_UseConfigIfChanged:
810 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
811 if (inst->mpb_Changed)
812 {
813 WritePrefsFile(inst, "ENV:Scalos/Menu13.prefs");
814 SetChangedFlag(inst, FALSE);
815 }
816 break;
817
818 case MUIM_ScalosPrefs_SaveConfig:
819 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
820 WritePrefsFile(inst, "ENVARC:Scalos/Menu13.prefs");
821 WritePrefsFile(inst, "ENV:Scalos/Menu13.prefs");
822 SetChangedFlag(inst, FALSE);
823 break;
824
825 case MUIM_ScalosPrefs_SaveConfigIfChanged:
826 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
827 if (inst->mpb_Changed)
828 {
829 WritePrefsFile(inst, "ENVARC:Scalos/Menu13.prefs");
830 WritePrefsFile(inst, "ENV:Scalos/Menu13.prefs");
831 SetChangedFlag(inst, FALSE);
832 }
833 break;
834
835 case MUIM_ScalosPrefs_RestoreConfig:
836 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
837 DoMethod(obj, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_Restore], 0);
838 break;
839
840 case MUIM_ScalosPrefs_ResetToDefaults:
841 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
842 DoMethod(obj, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ResetToDefaults], 0);
843 break;
844
845 case MUIM_ScalosPrefs_LastSavedConfig:
846 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
847 DoMethod(obj, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_LastSaved], 0);
848 break;
849
850 case MUIM_ScalosPrefs_PageActive:
851 {
852 struct MUIP_ScalosPrefs_PageActive *spa = (struct MUIP_ScalosPrefs_PageActive *) msg;
853
854 d1(kprintf("%s/%s/%ld: MUIM_ScalosPrefs_PageActive isActive=%08lx\n", __FILE__, __FUNC__, __LINE__, spa->isActive));
855 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
856 inst->mpb_PageIsActive = spa->isActive;
857 }
858 break;
859
860 case MUIM_ScalosPrefs_OpenConfig:
861 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
862 DoMethod(obj, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_Open], 0);
863 break;
864
865 case MUIM_ScalosPrefs_SaveConfigAs:
866 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
867 DoMethod(obj, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_SaveAs], 0);
868 break;
869
870 case MUIM_ScalosPrefs_About:
871 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
872 DoMethod(obj, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_About], 0);
873 break;
874
875 case MUIM_ScalosPrefs_LoadNamedConfig:
876 {
877 struct MUIP_ScalosPrefs_LoadNamedConfig *lnc = (struct MUIP_ScalosPrefs_LoadNamedConfig *) msg;
878
879 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
880 ClearMenuList(inst);
881 ReadPrefsFile(inst, lnc->ConfigFileName, FALSE);
882 }
883 break;
884
885 case MUIM_ScalosPrefs_MenuPrefs_ImportTD:
886 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
887 DoMethod(obj, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ImportTD], 0);
888 break;
889
890 case MUIM_ScalosPrefs_MenuPrefs_ImportP:
891 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
892 DoMethod(obj, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ImportP], 0);
893 break;
894
895 case MUIM_ScalosPrefs_MenuPrefs_Merge:
896 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
897 DoMethod(obj, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_Merge], 0);
898 break;
899
900 case MUIM_ScalosPrefs_MenuPrefs_CollapseAll:
901 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
902 DoMethod(obj, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_CollapseAll], 0);
903 break;
904
905 case MUIM_ScalosPrefs_MenuPrefs_ExpandAll:
906 inst = (struct MenuPrefsInst *) INST_DATA(cl, obj);
907 DoMethod(obj, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ExpandAll], 0);
908 break;
909
910 case MUIM_ScalosPrefs_CreateSubWindows:
911 result = (ULONG) NULL;
912 break;
913
914 case MUIM_ScalosPrefs_GetListOfMCCs:
915 result = (ULONG) RequiredMccList;
916 break;
917
918 default:
919 d1(kprintf("%s/%s/%ld: MethodID=%08lx\n", __FILE__, __FUNC__, __LINE__, msg->MethodID));
920 result = DoSuperMethodA(cl, obj, msg);
921 break;
922 }
923
924 return result;
925 }
926 DISPATCHER_END
927
928 //----------------------------------------------------------------------------
929
930 static Object *CreatePrefsGroup(struct MenuPrefsInst *inst)
931 {
932 d1(kprintf("%s/%s//%ld: inst=%08lx\n", __FILE__, __FUNC__, __LINE__, inst));
933
934 inst->mpb_Objects[OBJNDX_ContextMenu] = MUI_MakeObject(MUIO_MenustripNM, ContextMenus, 0);
935
936 inst->mpb_Objects[OBJNDX_Menu_Copy] = (Object *) DoMethod(inst->mpb_Objects[OBJNDX_ContextMenu],
937 MUIM_FindUData, HOOKNDX_MenuCopy);
938 inst->mpb_Objects[OBJNDX_Menu_Cut] = (Object *) DoMethod(inst->mpb_Objects[OBJNDX_ContextMenu],
939 MUIM_FindUData, HOOKNDX_MenuCut);
940 inst->mpb_Objects[OBJNDX_Menu_Paste] = (Object *) DoMethod(inst->mpb_Objects[OBJNDX_ContextMenu],
941 MUIM_FindUData, HOOKNDX_MenuPaste);
942 inst->mpb_Objects[OBJNDX_Menu_HideObsolete] = (Object *) DoMethod(inst->mpb_Objects[OBJNDX_ContextMenu],
943 MUIM_FindUData, HOOKNDX_HideObsolete);
944 inst->mpb_Objects[OBJNDX_Menu_CollapseSelected] = (Object *) DoMethod(inst->mpb_Objects[OBJNDX_ContextMenu],
945 MUIM_FindUData, HOOKNDX_CollapseSelected);
946 inst->mpb_Objects[OBJNDX_Menu_ExpandSelected] = (Object *) DoMethod(inst->mpb_Objects[OBJNDX_ContextMenu],
947 MUIM_FindUData, HOOKNDX_ExpandSelected);
948
949 inst->mpb_Objects[OBJNDX_Group_Main] = VGroup,
950 MUIA_Background, MUII_PageBack,
951
952 Child, inst->mpb_Objects[OBJNDX_Group_List] = VGroup,
953 MUIA_Frame, MUIV_Frame_Group,
954 MUIA_FrameTitle, GetLocString(MSGID_FRAMETITLE),
955
956 Child, HGroup,
957 Child, VGroup,
958 Child, inst->mpb_Objects[OBJNDX_MainListView] = NListviewObject,
959 MUIA_NListview_NList, inst->mpb_Objects[OBJNDX_MainListTree] = myNListTreeObject,
960 MUIA_CycleChain, TRUE,
961 MUIA_ContextMenu, inst->mpb_Objects[OBJNDX_ContextMenu],
962 MUIA_NList_PrivateData, inst,
963 MUIA_NList_Format, ",",
964 InputListFrame,
965 MUIA_Background, MUII_ListBack,
966 MUIA_NListtree_DisplayHook, &inst->mpb_Hooks[HOOKNDX_TreeDisplay],
967 MUIA_NListtree_ConstructHook, &inst->mpb_Hooks[HOOKNDX_TreeConstruct],
968 MUIA_NListtree_DestructHook, &inst->mpb_Hooks[HOOKNDX_TreeDestruct],
969 MUIA_NListtree_DragDropSort, TRUE,
970 MUIA_NList_ShowDropMarks, TRUE,
971 MUIA_NListtree_AutoVisible, MUIV_NListtree_AutoVisible_Expand,
972 End,
973 MUIA_ObjectID, MAKE_ID('M','T','R','E'),
974 MUIA_Listview_DragType, MUIV_Listview_DragType_Immediate,
975 End,
976
977 Child, NListviewObject,
978 MUIA_ShowMe, FALSE,
979 MUIA_NListview_NList, inst->mpb_Objects[OBJNDX_HiddenListTree] = myNListTreeObject,
980 MUIA_CycleChain, TRUE,
981 MUIA_NList_PrivateData, inst,
982 MUIA_NList_Format, ",",
983 InputListFrame,
984 MUIA_Background, MUII_ListBack,
985 MUIA_NListtree_DisplayHook, &inst->mpb_Hooks[HOOKNDX_TreeDisplay],
986 MUIA_NListtree_ConstructHook, &inst->mpb_Hooks[HOOKNDX_TreeConstruct],
987 MUIA_NListtree_DestructHook, &inst->mpb_Hooks[HOOKNDX_TreeDestruct],
988 End,
989 MUIA_Listview_DragType, MUIV_Listview_DragType_None,
990 End,
991
992 Child, NListviewObject,
993 MUIA_ShowMe, FALSE,
994 MUIA_NListview_NList, inst->mpb_Objects[OBJNDX_ListTreeClipboard] = myNListTreeObject,
995 MUIA_CycleChain, TRUE,
996 MUIA_NList_PrivateData, inst,
997 MUIA_NList_Format, ",",
998 InputListFrame,
999 MUIA_Background, MUII_ListBack,
1000 MUIA_NListtree_DisplayHook, &inst->mpb_Hooks[HOOKNDX_TreeDisplay],
1001 MUIA_NListtree_ConstructHook, &inst->mpb_Hooks[HOOKNDX_TreeConstruct],
1002 MUIA_NListtree_DestructHook, &inst->mpb_Hooks[HOOKNDX_TreeDestruct],
1003 End,
1004 MUIA_Listview_DragType, MUIV_Listview_DragType_None,
1005 End,
1006
1007 End, //VGroup
1008
1009 Child, BalanceObject,
1010 End, //Balance
1011
1012 Child, VGroup,
1013
1014 Child, inst->mpb_Objects[OBJNDX_Group_Name] = VGroup,
1015 Child, VGroup,
1016 Child, LLabel(GetLocString(MSGID_ENTRY_STRING_NAME)),
1017 Child, inst->mpb_Objects[OBJNDX_NameString] = StringObject,
1018 MUIA_CycleChain, TRUE,
1019 MUIA_Frame, MUIV_Frame_String,
1020 MUIA_String_MaxLen, MAX_NAMESIZE,
1021 End,
1022 End, //VGroup
1023 Child, HGroup,
1024 MUIA_Weight, 0,
1025 Child, Label(GetLocString(MSGID_HOTKEYNAME)),
1026 Child, inst->mpb_Objects[OBJNDX_StringHotkey] = StringObject,
1027 MUIA_CycleChain, TRUE,
1028 MUIA_String_MaxLen, 2,
1029 MUIA_Weight, 10,
1030 MUIA_Frame, MUIV_Frame_String,
1031 End,
1032 End,
1033 Child, HVSpace,
1034 End, //VGroup
1035
1036 Child, HVSpace,
1037
1038 Child, ColGroup(2),
1039 MUIA_FrameTitle, GetLocString(MSGID_ENTRY_GROUP_UNSELECTEDIMAGE),
1040 MUIA_Background, MUII_GroupBack,
1041 GroupFrame,
1042
1043 Child, inst->mpb_Objects[OBJNDX_PopAsl_UnselectedImage] = PopaslObject,
1044 MUIA_CycleChain, TRUE,
1045 MUIA_ShortHelp, GetLocString(MSGID_POPASL_UNSELECTEDIMAGE_SHORTHELP),
1046 MUIA_Popasl_Type, ASL_FileRequest,
1047 MUIA_Popasl_StartHook, &inst->mpb_Hooks[HOOKNDX_ImagePopAslFileStart],
1048 MUIA_Popstring_String, MUI_MakeObject(MUIO_String, NULL, MAX_COMMANDNAME),
1049 MUIA_Popstring_Button, PopButton(MUII_PopFile),
1050 End, //PopaslObject
1051
1052 Child, inst->mpb_Objects[OBJNDX_DtImage_UnselectedImage] = DataTypesImageObject,
1053 MUIA_ShortHelp, GetLocString(MSGID_SAMPLE_UNSELECTEDIMAGE_SHORTHELP),
1054 MUIA_ScaDtpic_Name, (ULONG) "",
1055 End, //DataTypesMCCObject
1056 End, //ColGroup
1057
1058 Child, ColGroup(2),
1059 MUIA_FrameTitle, GetLocString(MSGID_ENTRY_GROUP_SELECTEDIMAGE),
1060 MUIA_Background, MUII_GroupBack,
1061 GroupFrame,
1062
1063 Child, inst->mpb_Objects[OBJNDX_PopAsl_SelectedImage] = PopaslObject,
1064 MUIA_CycleChain, TRUE,
1065 MUIA_ShortHelp, GetLocString(MSGID_POPASL_SELECTEDIMAGE_SHORTHELP),
1066 MUIA_Popasl_Type, ASL_FileRequest,
1067 MUIA_Popasl_StartHook, &inst->mpb_Hooks[HOOKNDX_ImagePopAslFileStart],
1068 MUIA_Popstring_String, MUI_MakeObject(MUIO_String, NULL, MAX_COMMANDNAME),
1069 MUIA_Popstring_Button, PopButton(MUII_PopFile),
1070 End, //PopaslObject
1071
1072 Child, inst->mpb_Objects[OBJNDX_DtImage_SelectedImage] = DataTypesImageObject,
1073 MUIA_ShortHelp, GetLocString(MSGID_SAMPLE_SELECTEDIMAGE_SHORTHELP),
1074 MUIA_ScaDtpic_Name, (ULONG) "",
1075 End, //DataTypesMCCObject
1076
1077 End, //ColGroup
1078
1079 Child, HVSpace,
1080
1081 Child, inst->mpb_Objects[OBJNDX_Group_CmdProperties] = VGroup,
1082 MUIA_FrameTitle, GetLocString(MSGID_MENU_GROUP_COMMAND_PROPERTIES),
1083 MUIA_Background, MUII_GroupBack,
1084 GroupFrame,
1085
1086 Child, inst->mpb_Objects[OBJNDX_Group_String] = VGroup,
1087 Child, inst->mpb_Objects[OBJNDX_CycleGad] = CycleObject,
1088 MUIA_Cycle_Entries, CmdModeStrings,
1089 MUIA_Weight, 5,
1090 MUIA_CycleChain, TRUE,
1091 End,
1092
1093 Child, HGroup,
1094 Child, inst->mpb_Objects[OBJNDX_PopObject] = PopobjectObject,
1095 MUIA_ShowMe, FALSE,
1096 MUIA_CycleChain, TRUE,
1097 MUIA_Popstring_Button, PopButton(MUII_PopUp),
1098 MUIA_Popobject_StrObjHook, &inst->mpb_Hooks[HOOKNDX_CmdListPopupOpen],
1099 MUIA_Popobject_Object, inst->mpb_Objects[OBJNDX_CmdListView] = NListviewObject,
1100 MUIA_NListview_NList, NListObject,
1101 InputListFrame,
1102 MUIA_Background, MUII_ListBack,
1103 MUIA_NList_Format, ",",
1104 MUIA_NList_ConstructHook2, &inst->mpb_Hooks[HOOKNDX_CmdListConstruct],
1105 MUIA_NList_DestructHook2, &inst->mpb_Hooks[HOOKNDX_CmdListDestruct],
1106 MUIA_NList_DisplayHook2, &inst->mpb_Hooks[HOOKNDX_CmdListDisplay],
1107 MUIA_NList_CompareHook2, &inst->mpb_Hooks[HOOKNDX_CmdListCompare],
1108 MUIA_NList_AdjustWidth, TRUE,
1109 MUIA_NList_SortType, 1,
1110 MUIA_NList_TitleMark, MUIV_NList_TitleMark_Down | 1,
1111 MUIA_NList_SourceArray, CommandsArray,
1112 End, //NListObject
1113 End, //NListviewObject
1114 End, //PopobjectObject
1115
1116 Child, inst->mpb_Objects[OBJNDX_Popbutton] = PopButton(MUII_PopUp),
1117
1118 Child, inst->mpb_Objects[OBJNDX_StringCmd] = StringObject,
1119 MUIA_CycleChain, TRUE,
1120 MUIA_String_MaxLen, MAX_LINESIZE,
1121 MUIA_Frame, MUIV_Frame_String,
1122 End,
1123 End, //HGroup
1124 End, //VGroup
1125
1126 Child, HVSpace,
1127
1128 Child, ColGroup(4),
1129 Child, HVSpace,
1130
1131 Child, Label(GetLocString(MSGID_ARGSNAME)),
1132 Child, inst->mpb_Objects[OBJNDX_CheckArgs] = CheckMark(FALSE),
1133
1134 Child, HVSpace,
1135 End, //ColGroup
1136
1137 Child, ColGroup(2),
1138 Child, Label(GetLocString(MSGID_STACKNAME)),
1139 Child, inst->mpb_Objects[OBJNDX_StringStack] = StringObject,
1140 MUIA_CycleChain, TRUE,
1141 MUIA_Frame, MUIV_Frame_String,
1142 MUIA_Weight, 30,
1143 MUIA_String_Accept, "0123456789",
1144 MUIA_String_MaxLen, 10,
1145 MUIA_String_Integer, DEFAULT_STACKSIZE,
1146 End,
1147
1148 Child, Label(GetLocString(MSGID_PRIORITY_SLIDER_NAME)),
1149 Child, inst->mpb_Objects[OBJNDX_SliderPriority] = SliderObject,
1150 MUIA_CycleChain, TRUE,
1151 MUIA_Group_Horiz, TRUE,
1152 MUIA_Numeric_Min, -128,
1153 MUIA_Numeric_Max, 127,
1154 MUIA_Numeric_Value, 0,
1155 MUIA_ShortHelp, GetLocString(MSGID_PRIORITY_SLIDER_BUBBLE),
1156 End,
1157 End, //ColGroup
1158 End, //VGroup
1159 Child, HVSpace,
1160 End, //VGroup
1161 End, //HGroup
1162
1163 Child, HGroup,
1164 Child, inst->mpb_Objects[OBJNDX_Lamp_Changed] = LampObject,
1165 MUIA_Lamp_Type, MUIV_Lamp_Type_Huge,
1166 MUIA_Lamp_Color, MUIV_Lamp_Color_Off,
1167 MUIA_ShortHelp, GetLocString(MSGID_SHORTHELP_LAMP_CHANGED),
1168 End, //LampObject
1169
1170 Child, inst->mpb_Objects[OBJNDX_Group_Buttons1] = HGroup,
1171 MUIA_Group_SameWidth, TRUE,
1172 Child, inst->mpb_Objects[OBJNDX_NewMenuButton] = KeyButtonHelp(GetLocString(MSGID_NEWNAME),
1173 'm', GetLocString(MSGID_SHORTHELP_NEWMENUBUTTON)),
1174 Child, inst->mpb_Objects[OBJNDX_NewItemButton] = KeyButtonHelp(GetLocString(MSGID_NEWINAME),
1175 'i', GetLocString(MSGID_SHORTHELP_NEWITEMBUTTON)),
1176 Child, inst->mpb_Objects[OBJNDX_NewCommandButton] = KeyButtonHelp(GetLocString(MSGID_NEW2NAME),
1177 'c', GetLocString(MSGID_SHORTHELP_NEWCOMMANDBUTTON)),
1178 Child, inst->mpb_Objects[OBJNDX_DelButton] = KeyButtonHelp(GetLocString(MSGID_DELNAME),
1179 'd', GetLocString(MSGID_SHORTHELP_DELBUTTON)),
1180 End, //HGroup
1181 End, //HGroup
1182 End, //VGroup
1183
1184 MUIA_ContextMenu, inst->mpb_Objects[OBJNDX_ContextMenu],
1185 End;
1186
1187 if (NULL == inst->mpb_Objects[OBJNDX_Group_Main])
1188 return NULL;
1189
1190 d1(kprintf("%s/%s//%ld: ContextMenu=%08lx\n", __FILE__, __FUNC__, __LINE__, inst->mpb_Objects[OBJNDX_ContextMenu]));
1191
1192 set(inst->mpb_Objects[OBJNDX_Menu_HideObsolete], MUIA_Menuitem_Checked, inst->mpb_HideObsoletePopupMenus);
1193
1194 DoMethod(inst->mpb_Objects[OBJNDX_CmdListView], MUIM_NList_Sort);
1195
1196 DoMethod(inst->mpb_Objects[OBJNDX_CmdListView], MUIM_Notify, MUIA_Listview_DoubleClick, TRUE,
1197 inst->mpb_Objects[OBJNDX_CmdListView], 2, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_CmdSelected]);
1198 DoMethod(inst->mpb_Objects[OBJNDX_StringHotkey], MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime,
1199 inst->mpb_Objects[OBJNDX_MainListTree], 3, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ChangeHotkey], MUIV_TriggerValue);
1200
1201 DoMethod(inst->mpb_Objects[OBJNDX_PopAsl_UnselectedImage], MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime,
1202 inst->mpb_Objects[OBJNDX_MainListTree], 3, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ChangeUnselectedImage], MUIV_TriggerValue);
1203
1204 DoMethod(inst->mpb_Objects[OBJNDX_PopAsl_SelectedImage], MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime,
1205 inst->mpb_Objects[OBJNDX_MainListTree], 3, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ChangeSelectedImage], MUIV_TriggerValue);
1206
1207 DoMethod(inst->mpb_Objects[OBJNDX_NameString], MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime,
1208 inst->mpb_Objects[OBJNDX_MainListTree], 3, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_RenameEntry], MUIV_TriggerValue);
1209
1210 DoMethod(inst->mpb_Objects[OBJNDX_SliderPriority], MUIM_Notify, MUIA_Numeric_Value, MUIV_EveryTime,
1211 inst->mpb_Objects[OBJNDX_MainListTree], 2, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ChangeEntry3]);
1212
1213 DoMethod(inst->mpb_Objects[OBJNDX_StringStack], MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime,
1214 inst->mpb_Objects[OBJNDX_MainListTree], 2, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ChangeEntry3]);
1215
1216 DoMethod(inst->mpb_Objects[OBJNDX_StringCmd], MUIM_Notify, MUIA_String_Contents, MUIV_EveryTime,
1217 inst->mpb_Objects[OBJNDX_MainListTree], 2, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ChangeEntry3]);
1218
1219 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_Notify, MUIA_NListtree_Active, MUIV_EveryTime,
1220 inst->mpb_Objects[OBJNDX_MainListTree], 3, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_SelectEntry], MUIV_TriggerValue);
1221
1222 DoMethod(inst->mpb_Objects[OBJNDX_CycleGad], MUIM_Notify, MUIA_Cycle_Active, MUIV_EveryTime,
1223 inst->mpb_Objects[OBJNDX_MainListTree], 2, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ChangeEntry3]);
1224
1225 DoMethod(inst->mpb_Objects[OBJNDX_Popbutton], MUIM_Notify, MUIA_Pressed, FALSE,
1226 inst->mpb_Objects[OBJNDX_MainListTree], 2, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_PopButton]);
1227
1228 DoMethod(inst->mpb_Objects[OBJNDX_NewMenuButton], MUIM_Notify, MUIA_Pressed, FALSE,
1229 inst->mpb_Objects[OBJNDX_MainListTree], 2, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_AddMenu]);
1230
1231 DoMethod(inst->mpb_Objects[OBJNDX_NewItemButton], MUIM_Notify, MUIA_Pressed, FALSE,
1232 inst->mpb_Objects[OBJNDX_MainListTree], 2, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_AddMenuItem]);
1233
1234 DoMethod(inst->mpb_Objects[OBJNDX_NewCommandButton], MUIM_Notify, MUIA_Pressed, FALSE,
1235 inst->mpb_Objects[OBJNDX_MainListTree], 2, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_AddCommand]);
1236
1237 DoMethod(inst->mpb_Objects[OBJNDX_DelButton], MUIM_Notify, MUIA_Pressed, FALSE,
1238 inst->mpb_Objects[OBJNDX_MainListTree], 2, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_RemoveEntry]);
1239
1240
1241 DoMethod(inst->mpb_Objects[OBJNDX_CheckArgs], MUIM_Notify, MUIA_Selected, MUIV_EveryTime,
1242 inst->mpb_Objects[OBJNDX_MainListTree], 2, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ChangeEntry3]);
1243
1244 DoMethod(inst->mpb_Objects[OBJNDX_Group_Main], MUIM_Notify, MUIA_ContextMenuTrigger, MUIV_EveryTime,
1245 inst->mpb_Objects[OBJNDX_Group_Main], 3, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_ContextMenuTrigger], MUIV_TriggerValue );
1246
1247 DoMethod(inst->mpb_Objects[OBJNDX_Group_Main], MUIM_Notify, MUIA_AppMessage, MUIV_EveryTime,
1248 inst->mpb_Objects[OBJNDX_Group_Main], 3, MUIM_CallHook, &inst->mpb_Hooks[HOOKNDX_AppMessage], MUIV_TriggerValue);
1249
1250 d1(KPrintF("%s/%s//%ld: mpb_HideObsoletePopupMenus=%ld\n", __FILE__, __FUNC__, __LINE__, inst->mpb_HideObsoletePopupMenus));
1251
1252 InsertMenuRootEntries(inst);
1253
1254 d1(kprintf("%s/%s//%ld:\n", __FILE__, __FUNC__, __LINE__));
1255 d1(kprintf("%s/%s//%ld: LocaleBase=%08lx IFFParseBase=%08lx\n", __FILE__, __FUNC__, __LINE__, LocaleBase, IFFParseBase));
1256
1257 return inst->mpb_Objects[OBJNDX_Group_Main];
1258 }
1259
1260
1261 static BOOL OpenLibraries(void)
1262 {
1263 d1(kprintf("%s/%s//%ld:\n", __FILE__, __FUNC__, __LINE__));
1264
1265 DOSBase = (APTR) OpenLibrary( "dos.library", 39 );
1266 if (NULL == DOSBase)
1267 return FALSE;
1268 #ifdef __amigaos4__
1269 IDOS = (struct DOSIFace *)GetInterface((struct Library *)DOSBase, "main", 1, NULL);
1270 if (NULL == IDOS)
1271 return FALSE;
1272 #endif
1273
1274 IntuitionBase = (struct IntuitionBase *) OpenLibrary("intuition.library", 39);
1275 if (NULL == IntuitionBase)
1276 return FALSE;
1277 #ifdef __amigaos4__
1278 IIntuition = (struct IntuitionIFace *)GetInterface((struct Library *)IntuitionBase, "main", 1, NULL);
1279 if (NULL == IIntuition)
1280 return FALSE;
1281 #endif
1282
1283 MUIMasterBase = OpenLibrary("zune.library", 0);
1284 if (NULL == MUIMasterBase)
1285 MUIMasterBase = OpenLibrary(MUIMASTER_NAME, MUIMASTER_VMIN-1);
1286 if (NULL == MUIMasterBase)
1287 return FALSE;
1288 #ifdef __amigaos4__
1289 IMUIMaster = (struct MUIMasterIFace *)GetInterface((struct Library *)MUIMasterBase, "main", 1, NULL);
1290 if (NULL == IMUIMaster)
1291 return FALSE;
1292 #endif
1293
1294 IFFParseBase = OpenLibrary("iffparse.library", 36);
1295 if (NULL == IFFParseBase)
1296 return FALSE;
1297 #ifdef __amigaos4__
1298 IIFFParse = (struct IFFParseIFace *)GetInterface((struct Library *)IFFParseBase, "main", 1, NULL);
1299 if (NULL == IIFFParse)
1300 return FALSE;
1301 #endif
1302
1303 IconBase = OpenLibrary("icon.library", 0);
1304 if (NULL == IconBase)
1305 return FALSE;
1306 #ifdef __amigaos4__
1307 IIcon = (struct IconIFace *)GetInterface((struct Library *)IconBase, "main", 1, NULL);
1308 if (NULL == IIcon)
1309 return FALSE;
1310 #endif
1311
1312 GfxBase = (struct GfxBase *) OpenLibrary("graphics.library", 39);
1313 if (NULL == GfxBase)
1314 return FALSE;
1315 #ifdef __amigaos4__
1316 IGraphics = (struct GraphicsIFace *)GetInterface((struct Library *)GfxBase, "main", 1, NULL);
1317 if (NULL == IGraphics)
1318 return FALSE;
1319 #endif
1320
1321 UtilityBase = (T_UTILITYBASE) OpenLibrary(UTILITYNAME, 39);
1322 if (NULL == UtilityBase)
1323 return FALSE;
1324 #ifdef __amigaos4__
1325 IUtility = (struct UtilityIFace *)GetInterface((struct Library *)UtilityBase, "main", 1, NULL);
1326 if (NULL == IUtility)
1327 return FALSE;
1328 #endif
1329
1330 DataTypesBase = OpenLibrary("datatypes.library", 39);
1331 if (NULL == DataTypesBase)
1332 return FALSE;
1333 #ifdef __amigaos4__
1334 IDataTypes = (struct DataTypesIFace *)GetInterface((struct Library *)DataTypesBase, "main", 1, NULL);
1335 if (NULL == IDataTypes)
1336 return FALSE;
1337 #endif
1338
1339 #ifdef __amigaos4__
1340 NewlibBase = OpenLibrary("newlib.library", 0);
1341 if (NULL == NewlibBase)
1342 return FALSE;
1343 INewlib = GetInterface(NewlibBase, "main", 1, NULL);
1344 if (NULL == INewlib)
1345 return FALSE;
1346 #endif
1347
1348 LocaleBase = (T_LOCALEBASE) OpenLibrary("locale.library", 39);
1349 #ifdef __amigaos4__
1350 if (LocaleBase)
1351 ILocale = (struct LocaleIFace *)GetInterface((struct Library *)LocaleBase, "main", 1, NULL);
1352 #endif
1353
1354 d1(kprintf("%s/%s//%ld: LocaleBase=%08lx IFFParseBase=%08lx\n", __FILE__, __FUNC__, __LINE__, LocaleBase, IFFParseBase));
1355
1356 return TRUE;
1357 }
1358
1359
1360 static void CloseLibraries(void)
1361 {
1362 d1(kprintf("%s/%s//%ld:\n", __FILE__, __FUNC__, __LINE__));
1363
1364 #ifdef __amigaos4__
1365 if (ILocale)
1366 {
1367 DropInterface((struct Interface *)ILocale);
1368 ILocale = NULL;
1369 }
1370 #endif
1371 if (LocaleBase)
1372 {
1373 CloseLibrary((struct Library *) LocaleBase);
1374 LocaleBase = NULL;
1375 }
1376 #ifdef __amigaos4__
1377 if (INewlib)
1378 {
1379 DropInterface(INewlib);
1380 INewlib = NULL;
1381 }
1382 if (NewlibBase)
1383 {
1384 CloseLibrary(NewlibBase);
1385 NewlibBase = NULL;
1386 }
1387 if (IDataTypes)
1388 {
1389 DropInterface((struct Interface *)IDataTypes);
1390 IDataTypes = NULL;
1391 }
1392 #endif
1393 if (DataTypesBase)
1394 {
1395 CloseLibrary(DataTypesBase);
1396 DataTypesBase = NULL;
1397 }
1398 #ifdef __amigaos4__
1399 if (IUtility)
1400 {
1401 DropInterface((struct Interface *)IUtility);
1402 IUtility = NULL;
1403 }
1404 #endif
1405 if (UtilityBase)
1406 {
1407 CloseLibrary((struct Library *) UtilityBase);
1408 UtilityBase = NULL;
1409 }
1410 #ifdef __amigaos4__
1411 if (IGraphics)
1412 {
1413 DropInterface((struct Interface *)IGraphics);
1414 IGraphics = NULL;
1415 }
1416 #endif
1417 if (GfxBase)
1418 {
1419 CloseLibrary((struct Library *) GfxBase);
1420 GfxBase = NULL;
1421 }
1422 #ifdef __amigaos4__
1423 if (IIcon)
1424 {
1425 DropInterface((struct Interface *)IIcon);
1426 IIcon = NULL;
1427 }
1428 #endif
1429 if (IconBase)
1430 {
1431 CloseLibrary(IconBase);
1432 IconBase = NULL;
1433 }
1434 #ifdef __amigaos4__
1435 if (IIFFParse)
1436 {
1437 DropInterface((struct Interface *)IIFFParse);
1438 IIFFParse = NULL;
1439 }
1440 #endif
1441 if (IFFParseBase)
1442 {
1443 CloseLibrary(IFFParseBase);
1444 IFFParseBase = NULL;
1445 }
1446 #ifdef __amigaos4__
1447 if (IMUIMaster)
1448 {
1449 DropInterface((struct Interface *)IMUIMaster);
1450 IMUIMaster = NULL;
1451 }
1452 #endif
1453 if (MUIMasterBase)
1454 {
1455 CloseLibrary(MUIMasterBase);
1456 MUIMasterBase = NULL;
1457 }
1458 #ifdef __amigaos4__
1459 if (IIntuition)
1460 {
1461 DropInterface((struct Interface *)IIntuition);
1462 IIntuition = NULL;
1463 }
1464 #endif
1465 if (IntuitionBase)
1466 {
1467 CloseLibrary((struct Library *) IntuitionBase);
1468 IntuitionBase = NULL;
1469 }
1470 #ifdef __amigaos4__
1471 if (IDOS)
1472 {
1473 DropInterface((struct Interface *)IDOS);
1474 IDOS = NULL;
1475 }
1476 #endif
1477 if (DOSBase)
1478 {
1479 CloseLibrary((struct Library *) DOSBase);
1480 DOSBase = NULL;
1481 }
1482
1483 }
1484
1485 //----------------------------------------------------------------------------
1486
1487 static SAVEDS(APTR) INTERRUPT CmdListConstructHookFunc(struct Hook *hook, APTR obj, struct NList_ConstructMessage *msg)
1488 {
1489 (void) hook;
1490 (void) obj;
1491
1492 return msg->entry;
1493 }
1494
1495 static SAVEDS(void) INTERRUPT CmdListDestructHookFunc(struct Hook *hook, APTR obj, struct NList_DestructMessage *msg)
1496 {
1497 (void) hook;
1498 (void) obj;
1499 (void) msg;
1500 }
1501
1502
1503 static SAVEDS(ULONG) INTERRUPT CmdListDisplayHookFunc(struct Hook *hook, APTR obj, struct NList_DisplayMessage *ltdm)
1504 {
1505 struct CommandTableEntry *cte = (struct CommandTableEntry *) ltdm->entry;
1506
1507 d1(KPrintF(__FILE__ "/%s/%ld: cte=%08lx\n", __FUNC__, __LINE__, cte));
1508
1509 if (cte)
1510 {
1511 ltdm->preparses[0] = "";
1512
1513 ltdm->strings[0] = GetLocString(cte->cte_NameMsgId);
1514 ltdm->strings[1] = (STRPTR) cte->cte_Command;
1515 }
1516 else
1517 {
1518 // display titles
1519 ltdm->preparses[0] = "";
1520 ltdm->preparses[1] = "";
1521
1522 ltdm->strings[0] = "";
1523 ltdm->strings[1] = "";
1524 }
1525
1526 return 0;
1527 }
1528
1529
1530 static SAVEDS(LONG) INTERRUPT CmdListCompareHookFunc(struct Hook *hook, Object *obj, struct NList_CompareMessage *ncm)
1531 {
1532 const struct CommandTableEntry *cte1 = (const struct CommandTableEntry *) ncm->entry1;
1533 const struct CommandTableEntry *cte2 = (const struct CommandTableEntry *) ncm->entry2;
1534 LONG col1 = ncm->sort_type & MUIV_NList_TitleMark_ColMask;
1535 LONG col2 = ncm->sort_type2 & MUIV_NList_TitleMark2_ColMask;
1536 LONG Result = 0;
1537
1538 if (ncm->sort_type != MUIV_NList_SortType_None)
1539 {
1540 // primary sorting
1541 switch (col1)
1542 {
1543 case 0: // sort by full name
1544 if (ncm->sort_type & MUIV_NList_TitleMark_TypeMask)
1545 Result = Stricmp(GetLocString(cte2->cte_NameMsgId), GetLocString(cte1->cte_NameMsgId));
1546 else
1547 Result = Stricmp(GetLocString(cte1->cte_NameMsgId), GetLocString(cte2->cte_NameMsgId));
1548 break;
1549 case 1: // sort by internal name
1550 if (ncm->sort_type & MUIV_NList_TitleMark_TypeMask)
1551 Result = Stricmp(cte2->cte_Command, cte1->cte_Command);
1552 else
1553 Result = Stricmp(cte1->cte_Command, cte2->cte_Command);
1554 break;
1555 default:
1556 break;
1557 }
1558
1559 if (0 == Result && col1 != col2)
1560 {
1561 // Secondary sorting
1562 switch (col2)
1563 {
1564 case 0: // sort by full name
1565 if (ncm->sort_type2 & MUIV_NList_TitleMark2_TypeMask)
1566 Result = Stricmp(GetLocString(cte2->cte_NameMsgId), GetLocString(cte1->cte_NameMsgId));
1567 else
1568 Result = Stricmp(GetLocString(cte1->cte_NameMsgId), GetLocString(cte2->cte_NameMsgId));
1569 break;
1570 case 1: // sort by internal name
1571 if (ncm->sort_type2 & MUIV_NList_TitleMark2_TypeMask)
1572 Result = Stricmp(cte2->cte_Command, cte1->cte_Command);
1573 else
1574 Result = Stricmp(cte1->cte_Command, cte2->cte_Command);
1575 break;
1576 default:
1577 break;
1578 }
1579 }
1580 }
1581
1582 return Result;
1583 }
1584
1585 //----------------------------------------------------------------------------
1586
1587 static SAVEDS(LONG) INTERRUPT CmdListPopupOpenHookFunc(struct Hook *hook, Object *list, Object *str)
1588 {
1589 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
1590 ULONG entries = 0;
1591 ULONG n;
1592 CONST_STRPTR string = "";
1593 size_t length;
1594
1595 get(list, MUIA_NList_Entries, &entries);
1596 get(inst->mpb_Objects[OBJNDX_StringCmd], MUIA_String_Contents, &string);
1597
1598 length = strlen(string);
1599
1600 d1(KPrintF(__FILE__ "/%s/%ld: string=<%s> entries=%lu length=%lu\n", __FUNC__, __LINE__, string, entries, length));
1601
1602 for (n = 0; n < entries; n++)
1603 {
1604 struct CommandTableEntry *cte = NULL;
1605
1606 DoMethod(list, MUIM_NList_GetEntry, n, &cte);
1607 if (cte)
1608 {
1609 if (0 == Strnicmp(cte->cte_Command, string, length))
1610 {
1611 d1(KPrintF(__FILE__ "/%s/%ld: found!\n", __FUNC__, __LINE__, cte));
1612 set(list, MUIA_NList_Active, n);
1613 DoMethod(list, MUIM_NList_Jump, n);
1614 break;
1615 }
1616 }
1617 }
1618
1619 return TRUE;
1620 }
1621
1622 //----------------------------------------------------------------------------
1623
1624 static SAVEDS(APTR) INTERRUPT TreeConstructFunc(struct Hook *hook, APTR obj, struct MUIP_NListtree_ConstructMessage *ltcm)
1625 {
1626 struct MenuListEntry *mle = AllocPooled(ltcm->MemPool, sizeof(struct MenuListEntry));
1627
1628 d1(kprintf("%s/%s/%ld: obj=%08lx ltcm=%08lx memPool=%08lx UserData=%08lx\n", \
1629 __FILE__, __FUNC__, __LINE__, obj, ltcm, ltcm->MemPool, ltcm->UserData));
1630 d1(kprintf("%s/%s/%ld: mle=%08lx\n", __FILE__, __FUNC__, __LINE__, mle));
1631
1632 if (mle)
1633 {
1634 const struct MenuInsertEntry *mie = (const struct MenuInsertEntry *) ltcm->UserData;
1635 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
1636
1637 if (ltcm->Name)
1638 stccpy(mle->llist_name, ltcm->Name, sizeof(mle->llist_name));
1639 else
1640 strcpy(mle->llist_name, "");
1641
1642 d1(KPrintF("%s/%s/%ld: llist_name=<%s> mtre_type=%ld\n", __FILE__, __FUNC__, __LINE__, mle->llist_name, mie->mie_TreeEntry->mtre_type));
1643
1644 d1(KPrintF("%s/%s/%ld: mtre_iconnames=%08lx\n", __FILE__, __FUNC__, __LINE__, mie->mie_TreeEntry->MenuCombo.MenuTree.mtre_iconnames));
1645 if ((mie->mie_TreeEntry->mtre_flags & MTREFLGF_IconNames) &&
1646 mie->mie_TreeEntry->MenuCombo.MenuTree.mtre_iconnames)
1647 {
1648 stccpy(mle->llist_UnselectedIconName, mie->mie_TreeEntry->MenuCombo.MenuTree.mtre_iconnames,
1649 sizeof(mle->llist_UnselectedIconName));
1650 stccpy(mle->llist_SelectedIconName,
1651 mie->mie_TreeEntry->MenuCombo.MenuTree.mtre_iconnames + 1 + strlen(mie->mie_TreeEntry->MenuCombo.MenuTree.mtre_iconnames),
1652 sizeof(mle->llist_SelectedIconName));
1653
1654 d1(KPrintF("%s/%s/%ld: llist_UnselectedIconName=<%s> llist_SelectedIconName=<%s>\n", __FILE__, __FUNC__, __LINE__, mle->llist_UnselectedIconName, mle->llist_SelectedIconName));
1655
1656 mle->llist_UnSelImageIndex = ++inst->mpb_TreeImageIndex;
1657
1658 mle->llist_UnSelImageObj = DataTypesImageObject,
1659 MUIA_ScaDtpic_Name, (ULONG) mle->llist_UnselectedIconName,
1660 End;
1661
1662 d1(KPrintF("%s/%s/%ld: llist_UnSelImageObj=%08lx\n", __FILE__, __FUNC__, __LINE__, mle->llist_UnSelImageObj));
1663
1664 DoMethod(obj, MUIM_NList_UseImage, mle->llist_UnSelImageObj, mle->llist_UnSelImageIndex, 0);
1665 }
1666 else
1667 {
1668 mle->llist_UnSelImageIndex = 0;
1669 strcpy(mle->llist_UnselectedIconName, "");
1670 strcpy(mle->llist_SelectedIconName, "");
1671 }
1672
1673 ltcm->UserData = mle;
1674 ltcm->Name = mle->llist_name;
1675 mle->llist_EntryType = mie->mie_TreeEntry->mtre_type;
1676 mle->llist_Flags = mie->mie_MenuFlags;
1677
1678 d1(kprintf("%s/%s/%ld: EntryName=<%s> mie_MenuFlags=%02lx EntryType=%ld\n", \
1679 __FILE__, __FUNC__, __LINE__, ltcm->Name, mie->mie_MenuFlags, mie->mie_TreeEntry->mtre_type));
1680
1681 d1(kprintf("%s/%s/%ld: llist_HotKey=%08lx mtre_hotkey=%08lx\n", \
1682 __FILE__, __FUNC__, __LINE__, mle->llist_HotKey, mie->mie_TreeEntry->MenuCombo.MenuTree.mtre_hotkey));
1683
1684 stccpy(mle->llist_HotKey, mie->mie_TreeEntry->MenuCombo.MenuTree.mtre_hotkey, sizeof(mle->llist_HotKey));
1685
1686 if (SCAMENUTYPE_Command == mle->llist_EntryType)
1687 {
1688 d1(kprintf("%s/%s/%ld: llist_name=%08lx mcom_name=%08lx\n", \
1689 __FILE__, __FUNC__, __LINE__, mle->llist_name, mie->mie_TreeEntry->MenuCombo.MenuCommand.mcom_name));
1690
1691 stccpy(mle->llist_name,
1692 mie->mie_TreeEntry->MenuCombo.MenuCommand.mcom_name ? mie->mie_TreeEntry->MenuCombo.MenuCommand.mcom_name : (STRPTR) "",
1693 sizeof(mle->llist_name));
1694
1695 mle->llist_Priority = mie->mie_TreeEntry->MenuCombo.MenuCommand.mcom_pri;
1696 mle->llist_CommandType = mie->mie_TreeEntry->MenuCombo.MenuCommand.mcom_type;
1697 mle->llist_CommandFlags = mie->mie_TreeEntry->MenuCombo.MenuCommand.mcom_flags;
1698 mle->llist_Stack = mie->mie_TreeEntry->MenuCombo.MenuCommand.mcom_stack;
1699 }
1700 }
1701
1702 return mle;
1703 }
1704
1705 static SAVEDS(void) INTERRUPT TreeDestructFunc(struct Hook *hook, APTR obj, struct MUIP_NListtree_DestructMessage *ltdm)
1706 {
1707 struct MenuListEntry *mle = (struct MenuListEntry *) ltdm->UserData;
1708
1709 d1(kprintf("%s/%s/%ld: mle=%08lx\n", __FILE__, __FUNC__, __LINE__, mle));
1710
1711 if (mle)
1712 {
1713 if (mle->llist_UnSelImageObj)
1714 {
1715 DoMethod(obj, MUIM_NList_UseImage, NULL, mle->llist_UnSelImageIndex, 0);
1716
1717 MUI_DisposeObject(mle->llist_UnSelImageObj);
1718 mle->llist_UnSelImageObj = NULL;
1719 }
1720 FreePooled(ltdm->MemPool, mle, sizeof(struct MenuListEntry));
1721 }
1722
1723 ltdm->UserData = NULL;
1724 }
1725
1726 static SAVEDS(ULONG) INTERRUPT TreeDisplayFunc(struct Hook *hook, APTR obj, struct MUIP_NListtree_DisplayMessage *ltdm)
1727 {
1728 static CONST_STRPTR EntryTypeNames[] =
1729 {
1730 "\33b\33u", // MainMenu
1731 "\33b", // Menu
1732 "", // MenuItem
1733 "\33i", // Command
1734 "\33b\338" // ToolsMenu
1735 };
1736 struct MenuListEntry *mle = (struct MenuListEntry *) ltdm->TreeNode->tn_User;
1737
1738 d1(kprintf("%s/%s/%ld: mle=%08lx\n", __FILE__, __FUNC__, __LINE__, mle));
1739
1740 if (mle)
1741 {
1742 ltdm->Preparse[0] = (STRPTR) EntryTypeNames[mle->llist_EntryType];
1743
1744 d1(kprintf("%s/%s/%ld: EntryName=<%s> commandType=%ld\n", \
1745 __FILE__, __FUNC__, __LINE__, mle->llist_name, mle->llist_CommandType));
1746
1747 switch (mle->llist_EntryType)
1748 {
1749 case SCAMENUTYPE_Command:
1750 ltdm->Array[0] = mle->llist_name;
1751 ltdm->Array[1] = "";
1752 break;
1753 case SCAMENUTYPE_MenuItem:
1754 if (0 == strlen(ltdm->TreeNode->tn_Name))
1755 ltdm->Array[0] = GetLocString(MSGID_BARNAME);
1756 else
1757 {
1758 if (mle->llist_UnSelImageObj)
1759 {
1760 snprintf(mle->llist_MenuItemName, sizeof(mle->llist_MenuItemName),
1761 "\33o[%ld]%s",
1762 (long)mle->llist_UnSelImageIndex, ltdm->TreeNode->tn_Name);
1763 ltdm->Array[0] = mle->llist_MenuItemName;
1764 }
1765 else
1766 {
1767 ltdm->Array[0] = ltdm->TreeNode->tn_Name;
1768 }
1769 }
1770 ltdm->Array[1] = mle->llist_HotKey;
1771 break;
1772 default:
1773 ltdm->Array[0] = ltdm->TreeNode->tn_Name;
1774 ltdm->Array[1] = "";
1775 break;
1776 }
1777 }
1778
1779 return 0;
1780 }
1781
1782 //----------------------------------------------------------------------------
1783
1784 static SAVEDS(ULONG) INTERRUPT ImagePopAslFileStartHookFunc(struct Hook *hook, Object *o, Msg msg)
1785 {
1786 struct TagItem *TagList = (struct TagItem *) msg;
1787 // struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
1788
1789 d1(KPrintF("%s/%ld: inst=%08lx\n", __FUNC__, __LINE__, inst));
1790
1791 while (TAG_END != TagList->ti_Tag)
1792 TagList++;
1793
1794 TagList->ti_Tag = ASLFR_DrawersOnly;
1795 TagList->ti_Data = FALSE;
1796 TagList++;
1797
1798 // TagList->ti_Tag = ASLFR_InitialFile;
1799 // TagList->ti_Data = (ULONG) inst->fpb_FileName;
1800 // TagList++;
1801
1802 TagList->ti_Tag = ASLFR_InitialDrawer;
1803 TagList->ti_Data = (ULONG) "THEME:FileTypes/";
1804 TagList++;
1805
1806 TagList->ti_Tag = TAG_END;
1807
1808 return TRUE;
1809 }
1810
1811 //----------------------------------------------------------------------------
1812
1813 static STRPTR GetLocString(ULONG MsgId)
1814 {
1815 struct ScalosMenu_LocaleInfo li;
1816
1817 li.li_Catalog = MenuPrefsCatalog;
1818 #ifndef __amigaos4__
1819 li.li_LocaleBase = LocaleBase;
1820 #else
1821 li.li_ILocale = ILocale;
1822 #endif
1823
1824 return (STRPTR) GetScalosMenuString(&li, MsgId);
1825 }
1826
1827 static void TranslateStringArray(STRPTR *stringArray)
1828 {
1829 while (*stringArray)
1830 {
1831 *stringArray = GetLocString((ULONG) *stringArray);
1832 stringArray++;
1833 }
1834 }
1835
1836 static void TranslateNewMenu(struct NewMenu *nm)
1837 {
1838 while (nm && NM_END != nm->nm_Type)
1839 {
1840 if (NM_BARLABEL != nm->nm_Label)
1841 nm->nm_Label = GetLocString((ULONG) nm->nm_Label);
1842
1843 if (nm->nm_CommKey)
1844 nm->nm_CommKey = GetLocString((ULONG) nm->nm_CommKey);
1845
1846 nm++;
1847 }
1848 }
1849
1850 //----------------------------------------------------------------------------
1851
1852 static SAVEDS(APTR) INTERRUPT ResetToDefaultsHookFunc(struct Hook *hook, Object *o, Msg msg)
1853 {
1854 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
1855
1856 d1(KPrintF("%s/%s//%ld: START\n", __FILE__, __FUNC__, __LINE__));
1857
1858 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, TRUE);
1859 set(inst->mpb_Objects[OBJNDX_HiddenListTree], MUIA_NListtree_Quiet, TRUE);
1860 d1(KPrintF("%s/%s//%ld: \n", __FILE__, __FUNC__, __LINE__));
1861
1862 // Remove main menu contents
1863 ClearMenuList(inst);
1864 d1(KPrintF("%s/%s//%ld: \n", __FILE__, __FUNC__, __LINE__));
1865
1866 set(inst->mpb_MainMenuNode.mpn_Listtree,
1867 MUIA_NListtree_Active, (ULONG) inst->mpb_MainMenuNode.mpn_ListNode);
1868
1869 d1(KPrintF("%s/%s//%ld: \n", __FILE__, __FUNC__, __LINE__));
1870
1871 AddDefaultMenuContents(inst);
1872
1873 d1(KPrintF("%s/%s//%ld: \n", __FILE__, __FUNC__, __LINE__));
1874
1875 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NListtree_Close,
1876 MUIV_NListtree_Close_ListNode_Root, MUIV_NListtree_Close_TreeNode_All, 0);
1877
1878 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, FALSE);
1879 set(inst->mpb_Objects[OBJNDX_HiddenListTree], MUIA_NListtree_Quiet, FALSE);
1880
1881 d1(KPrintF("%s/%s//%ld: END\n", __FILE__, __FUNC__, __LINE__));
1882
1883 return 0;
1884 }
1885
1886 //----------------------------------------------------------------------------
1887
1888 static SAVEDS(APTR) INTERRUPT OpenHookFunc(struct Hook *hook, Object *o, Msg msg)
1889 {
1890 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
1891
1892 if (NULL == inst->mpb_LoadReq)
1893 {
1894 inst->mpb_LoadReq = MUI_AllocAslRequestTags(ASL_FileRequest,
1895 ASLFR_InitialFile, "Menu.pre",
1896 ASLFR_Flags1, FRF_DOPATTERNS,
1897 ASLFR_InitialDrawer, "SYS:Prefs/presets",
1898 ASLFR_InitialPattern, "#?.(pre|prefs)",
1899 ASLFR_UserData, inst,
1900 ASLFR_IntuiMsgFunc, &inst->mpb_Hooks[HOOKNDX_AslIntuiMsg],
1901 TAG_END);
1902 }
1903 if (inst->mpb_LoadReq)
1904 {
1905 BOOL Result;
1906 struct Window *win = NULL;
1907
1908 get(inst->mpb_Objects[OBJNDX_WIN_Main], MUIA_Window_Window, &win);
1909
1910 //AslRequest(
1911 Result = MUI_AslRequestTags(inst->mpb_LoadReq,
1912 ASLFR_Window, win,
1913 ASLFR_SleepWindow, TRUE,
1914 ASLFR_TitleText, GetLocString(MSGID_MENU_PROJECT_OPEN),
1915 TAG_END);
1916
1917 if (Result)
1918 {
1919 BPTR dirLock = Lock(inst->mpb_LoadReq->fr_Drawer, ACCESS_READ);
1920
1921 if (dirLock)
1922 {
1923 BPTR oldDir = CurrentDir(dirLock);
1924
1925 ClearMenuList(inst);
1926 ReadPrefsFile(inst, inst->mpb_LoadReq->fr_File, FALSE);
1927
1928 CurrentDir(oldDir);
1929 UnLock(dirLock);
1930 }
1931 }
1932 }
1933
1934 return 0;
1935 }
1936
1937
1938 static SAVEDS(APTR) INTERRUPT MergeHookFunc(struct Hook *hook, Object *o, Msg msg)
1939 {
1940 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
1941
1942 if (NULL == inst->mpb_LoadReq)
1943 {
1944 inst->mpb_LoadReq = MUI_AllocAslRequestTags(ASL_FileRequest,
1945 ASLFR_InitialFile, "Menu.pre",
1946 ASLFR_Flags1, FRF_DOPATTERNS,
1947 ASLFR_InitialDrawer, "SYS:Prefs/presets",
1948 ASLFR_InitialPattern, "#?.(pre|prefs)",
1949 ASLFR_UserData, inst,
1950 ASLFR_IntuiMsgFunc, &inst->mpb_Hooks[HOOKNDX_AslIntuiMsg],
1951 TAG_END);
1952 }
1953 if (inst->mpb_LoadReq)
1954 {
1955 BOOL Result;
1956 struct Window *win = NULL;
1957
1958 get(inst->mpb_Objects[OBJNDX_WIN_Main], MUIA_Window_Window, &win);
1959
1960 //AslRequest(
1961 Result = MUI_AslRequestTags(inst->mpb_LoadReq,
1962 ASLFR_Window, win,
1963 ASLFR_SleepWindow, TRUE,
1964 ASLFR_TitleText, GetLocString(MSGID_MENU_PROJECT_MERGE_ASLTITLE),
1965 TAG_END);
1966
1967 if (Result)
1968 {
1969 BPTR dirLock = Lock(inst->mpb_LoadReq->fr_Drawer, ACCESS_READ);
1970
1971 if (dirLock)
1972 {
1973 BPTR oldDir = CurrentDir(dirLock);
1974
1975 ReadPrefsFile(inst, inst->mpb_LoadReq->fr_File, FALSE);
1976
1977 SetChangedFlag(inst, TRUE);
1978
1979 CurrentDir(oldDir);
1980 UnLock(dirLock);
1981 }
1982 }
1983 }
1984
1985 return 0;
1986 }
1987
1988 static SAVEDS(APTR) INTERRUPT LastSavedHookFunc(struct Hook *hook, Object *o, Msg msg)
1989 {
1990 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
1991
1992 ClearMenuList(inst);
1993 ReadPrefsFile(inst, "ENVARC:Scalos/Menu13.prefs", FALSE);
1994 SetChangedFlag(inst, TRUE);
1995
1996 return 0;
1997 }
1998
1999 static SAVEDS(APTR) INTERRUPT RestoreHookFunc(struct Hook *hook, Object *o, Msg msg)
2000 {
2001 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2002
2003 ClearMenuList(inst);
2004 ReadPrefsFile(inst, "ENV:Scalos/Menu13.prefs", FALSE);
2005 SetChangedFlag(inst, TRUE);
2006
2007 return 0;
2008 }
2009
2010 static SAVEDS(APTR) INTERRUPT SaveAsHookFunc(struct Hook *hook, Object *o, Msg msg)
2011 {
2012 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2013
2014 if (NULL == inst->mpb_SaveReq)
2015 {
2016 CONST_STRPTR InitialDrawer;
2017 CONST_STRPTR InitialFile;
2018
2019 if (inst->mpb_LoadReq)
2020 {
2021 InitialDrawer = inst->mpb_LoadReq->fr_Drawer;
2022 InitialFile = inst->mpb_LoadReq->fr_File;
2023 }
2024 else
2025 {
2026 InitialDrawer = "SYS:Prefs/presets";
2027 InitialFile = "Menu.pre";
2028 }
2029
2030 inst->mpb_SaveReq = MUI_AllocAslRequestTags(ASL_FileRequest,
2031 ASLFR_InitialFile, InitialFile,
2032 ASLFR_DoSaveMode, TRUE,
2033 ASLFR_InitialDrawer, InitialDrawer,
2034 ASLFR_UserData, inst,
2035 ASLFR_IntuiMsgFunc, &inst->mpb_Hooks[HOOKNDX_AslIntuiMsg],
2036 TAG_END);
2037 }
2038 if (inst->mpb_SaveReq)
2039 {
2040 BOOL Result;
2041 struct Window *win = NULL;
2042
2043 get(inst->mpb_Objects[OBJNDX_WIN_Main], MUIA_Window_Window, &win);
2044
2045 //AslRequest(
2046 Result = MUI_AslRequestTags(inst->mpb_SaveReq,
2047 ASLFR_TitleText, GetLocString(MSGID_MENU_PROJECT_SAVEAS),
2048 ASLFR_Window, win,
2049 ASLFR_SleepWindow, TRUE,
2050 TAG_END);
2051
2052 if (Result)
2053 {
2054 BPTR dirLock = Lock(inst->mpb_SaveReq->fr_Drawer, ACCESS_READ);
2055
2056 if (dirLock)
2057 {
2058 BPTR oldDir = CurrentDir(dirLock);
2059
2060 WritePrefsFile(inst, inst->mpb_SaveReq->fr_File);
2061
2062 CurrentDir(oldDir);
2063 UnLock(dirLock);
2064 }
2065 }
2066 }
2067
2068 return 0;
2069 }
2070
2071
2072 static SAVEDS(APTR) INTERRUPT AboutHookFunc(struct Hook *hook, Object *o, Msg msg)
2073 {
2074 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2075
2076 MUI_Request(inst->mpb_Objects[OBJNDX_APP_Main], inst->mpb_Objects[OBJNDX_WIN_Main], 0, NULL,
2077 GetLocString(MSGID_ABOUTREQOK),
2078 GetLocString(MSGID_ABOUTREQFORMAT),
2079 MajorVersion, MinorVersion, COMPILER_STRING, CURRENTYEAR);
2080
2081 return 0;
2082 }
2083
2084 //----------------------------------------------------------------------------
2085
2086 static SAVEDS(APTR) INTERRUPT RenameEntryHookFunc(struct Hook *hook, Object *o, Msg msg)
2087 {
2088 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2089 struct MUI_NListtree_TreeNode *TreeNode;
2090
2091 if (inst->mpb_QuietFlag)
2092 return 0;
2093
2094 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2095 MUIM_NListtree_GetEntry,
2096 MUIV_NListtree_GetEntry_ListNode_Active,
2097 MUIV_NListtree_GetEntry_Position_Active, 0);
2098
2099 if (TreeNode)
2100 {
2101 struct MenuListEntry *mle = (struct MenuListEntry *) TreeNode->tn_User;
2102 STRPTR newName = "";
2103 BOOL MayAddCommand, MayHaveHotkey;
2104
2105 SetChangedFlag(inst, TRUE);
2106
2107 get(inst->mpb_Objects[OBJNDX_NameString], MUIA_String_Contents, &newName);
2108
2109 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, TRUE);
2110
2111 stccpy(mle->llist_name, newName, sizeof(mle->llist_name));
2112
2113 if (0 == strlen(newName))
2114 {
2115 // Remove all children from the new "=== Bar ==="
2116 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2117 MUIM_NListtree_Remove,
2118 TreeNode,
2119 MUIV_NListtree_Remove_TreeNode_All);
2120
2121 // BAR may not have a hotkey
2122 strcpy(mle->llist_HotKey, "");
2123
2124 TreeNode->tn_Flags |= TNF_NOSIGN;
2125 }
2126 else
2127 {
2128 TreeNode->tn_Flags &= ~TNF_NOSIGN;
2129 }
2130
2131 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2132 MUIM_NListtree_Rename,
2133 TreeNode,
2134 newName,
2135 0);
2136
2137 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, FALSE);
2138
2139 MayAddCommand = (strlen(mle->llist_name) > 0) &&
2140 ((SCAMENUTYPE_MenuItem == mle->llist_EntryType)
2141 || (SCAMENUTYPE_Command == mle->llist_EntryType));
2142
2143 MayHaveHotkey = (strlen(mle->llist_name) > 0)
2144 && SCAMENUTYPE_MenuItem == mle->llist_EntryType;
2145
2146 set(inst->mpb_Objects[OBJNDX_StringHotkey], MUIA_Disabled, !MayHaveHotkey);
2147 set(inst->mpb_Objects[OBJNDX_NewCommandButton], MUIA_Disabled, !MayAddCommand);
2148 }
2149
2150 return 0;
2151 }
2152
2153
2154 static SAVEDS(APTR) INTERRUPT ChangeHotkeyHookFunc(struct Hook *hook, Object *o, Msg msg)
2155 {
2156 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2157 STRPTR newHotKey = *(STRPTR *) msg;
2158 struct MUI_NListtree_TreeNode *TreeNode;
2159
2160 if (inst->mpb_QuietFlag)
2161 return 0;
2162
2163 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2164 MUIM_NListtree_GetEntry,
2165 MUIV_NListtree_GetEntry_ListNode_Active,
2166 MUIV_NListtree_GetEntry_Position_Active, 0);
2167
2168 if (TreeNode)
2169 {
2170 struct MenuListEntry *mle = (struct MenuListEntry *) TreeNode->tn_User;
2171
2172 SetChangedFlag(inst, TRUE);
2173
2174 mle->llist_HotKey[0] = *newHotKey;
2175 mle->llist_HotKey[1] = '\0';
2176
2177 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2178 MUIM_NListtree_Redraw,
2179 TreeNode,
2180 0);
2181 }
2182
2183 return 0;
2184 }
2185
2186 static SAVEDS(APTR) INTERRUPT ChangeEntry3HookFunc(struct Hook *hook, Object *o, Msg msg)
2187 {
2188 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2189 struct MUI_NListtree_TreeNode *TreeNode;
2190
2191 if (inst->mpb_QuietFlag)
2192 return 0;
2193
2194 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2195 MUIM_NListtree_GetEntry,
2196 MUIV_NListtree_GetEntry_ListNode_Active,
2197 MUIV_NListtree_GetEntry_Position_Active, 0);
2198
2199 if (TreeNode)
2200 {
2201 struct MenuListEntry *mle = (struct MenuListEntry *) TreeNode->tn_User;
2202
2203 if (SCAMENUTYPE_Command == mle->llist_EntryType)
2204 {
2205 STRPTR string = NULL;
2206 ULONG Value = 0;
2207 LONG sValue = 0;
2208
2209 SetChangedFlag(inst, TRUE);
2210
2211 get(inst->mpb_Objects[OBJNDX_StringCmd], MUIA_String_Contents, &string);
2212 stccpy(mle->llist_name, string, sizeof(mle->llist_name));
2213
2214 get(inst->mpb_Objects[OBJNDX_CycleGad], MUIA_Cycle_Active, &Value);
2215 mle->llist_CommandType = Value;
2216
2217 SwitchPopButton(inst, Value);
2218
2219 get(inst->mpb_Objects[OBJNDX_CheckArgs], MUIA_Selected, &Value);
2220 if (Value)
2221 mle->llist_CommandFlags |= MCOMFLGF_Args;
2222 else
2223 mle->llist_CommandFlags &= ~MCOMFLGF_Args;
2224
2225 EnableCommandArgumentGadgets(inst, mle);
2226
2227 get(inst->mpb_Objects[OBJNDX_StringStack], MUIA_String_Integer, &mle->llist_Stack);
2228
2229 get(inst->mpb_Objects[OBJNDX_SliderPriority], MUIA_Numeric_Value, &sValue);
2230 mle->llist_Priority = sValue;
2231
2232 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NList_Redraw, MUIV_NList_Redraw_Active);
2233 }
2234 }
2235
2236 return 0;
2237 }
2238
2239
2240 static SAVEDS(APTR) INTERRUPT ChangeUnselectedImageHookFunc(struct Hook *hook, Object *o, Msg msg)
2241 {
2242 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2243 STRPTR NewImage = *(STRPTR *) msg;
2244 struct MUI_NListtree_TreeNode *TreeNode;
2245
2246 if (inst->mpb_QuietFlag)
2247 return 0;
2248
2249 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(o,
2250 MUIM_NListtree_GetEntry,
2251 MUIV_NListtree_GetEntry_ListNode_Active,
2252 MUIV_NListtree_GetEntry_Position_Active, 0);
2253
2254 if (TreeNode)
2255 {
2256 struct MenuListEntry *mle = (struct MenuListEntry *) TreeNode->tn_User;
2257
2258 SetChangedFlag(inst, TRUE);
2259
2260 stccpy(mle->llist_UnselectedIconName, NewImage, sizeof(mle->llist_UnselectedIconName));
2261 set(inst->mpb_Objects[OBJNDX_DtImage_UnselectedImage], MUIA_ScaDtpic_Name, (ULONG) mle->llist_UnselectedIconName);
2262
2263 if (mle->llist_UnSelImageObj)
2264 {
2265 MUI_DisposeObject(mle->llist_UnSelImageObj);
2266 mle->llist_UnSelImageObj = NULL;
2267
2268 DoMethod(o, MUIM_NList_UseImage, mle->llist_UnSelImageObj, mle->llist_UnSelImageIndex, 0);
2269 }
2270 if (0 == mle->llist_UnSelImageIndex)
2271 mle->llist_UnSelImageIndex = ++inst->mpb_TreeImageIndex;
2272
2273 if (strlen(mle->llist_UnselectedIconName) > 0)
2274 {
2275 mle->llist_UnSelImageObj = DataTypesImageObject,
2276 MUIA_ScaDtpic_Name, (ULONG) mle->llist_UnselectedIconName,
2277 End;
2278 DoMethod(o, MUIM_NList_UseImage, mle->llist_UnSelImageObj, mle->llist_UnSelImageIndex, 0);
2279 }
2280
2281 DoMethod(o,
2282 MUIM_NListtree_Redraw,
2283 TreeNode,
2284 0);
2285 }
2286
2287 return 0;
2288 }
2289
2290
2291 static SAVEDS(APTR) INTERRUPT ChangeSelectedImageHookFunc(struct Hook *hook, Object *o, Msg msg)
2292 {
2293 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2294 STRPTR NewImage = *(STRPTR *) msg;
2295 struct MUI_NListtree_TreeNode *TreeNode;
2296
2297 if (inst->mpb_QuietFlag)
2298 return 0;
2299
2300 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(o,
2301 MUIM_NListtree_GetEntry,
2302 MUIV_NListtree_GetEntry_ListNode_Active,
2303 MUIV_NListtree_GetEntry_Position_Active, 0);
2304
2305 if (TreeNode)
2306 {
2307 struct MenuListEntry *mle = (struct MenuListEntry *) TreeNode->tn_User;
2308
2309 SetChangedFlag(inst, TRUE);
2310
2311 stccpy(mle->llist_SelectedIconName, NewImage, sizeof(mle->llist_SelectedIconName));
2312 set(inst->mpb_Objects[OBJNDX_DtImage_SelectedImage], MUIA_ScaDtpic_Name, (ULONG) mle->llist_SelectedIconName);
2313
2314 DoMethod(o,
2315 MUIM_NListtree_Redraw,
2316 TreeNode,
2317 0);
2318 }
2319
2320 return 0;
2321 }
2322
2323
2324 static SAVEDS(APTR) INTERRUPT SelectEntryHookFunc(struct Hook *hook, Object *o, Msg msg)
2325 {
2326 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2327 struct MUI_NListtree_TreeNode *TreeNode = *(struct MUI_NListtree_TreeNode **) msg;
2328
2329 if (inst->mpb_QuietFlag)
2330 return 0;
2331
2332 inst->mpb_QuietFlag = TRUE;
2333
2334 if (TreeNode)
2335 {
2336 struct MenuListEntry *mle = (struct MenuListEntry *) TreeNode->tn_User;
2337
2338 if (mle)
2339 {
2340 struct MUI_NListtree_TreeNode *tnShadow;
2341 BOOL MayAddNewMenu, MayAddNewItem, MayAddCommand;
2342 BOOL MayChangeName, MayDelete, MayHaveHotkey;
2343 BOOL MayHaveImage;
2344 enum MenuEntryType menuType;
2345 ULONG Count, MaxCount;
2346
2347 Count = DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NListtree_GetNr,
2348 TreeNode, MUIV_NListtree_GetNr_Flag_CountLevel);
2349
2350 menuType = GetMenuEntryType(inst, TreeNode);
2351 MaxCount = GetMaxCountForEntry(menuType);
2352
2353 MayAddNewMenu = (SCAMENUTYPE_Command != mle->llist_EntryType) &&
2354 Count < MaxCount &&
2355 menuType < MENUENTRY_SubItem;
2356
2357 d1(kprintf("%s/%s/%ld: menuType=%lu EntryCount=%lu MaxCount=%lu\n", \
2358 __FILE__, __FUNC__, __LINE__, menuType, Count, MaxCount));
2359
2360 MayAddNewItem = ((SCAMENUTYPE_MainMenu != mle->llist_EntryType) || (mle->llist_Flags & LLISTFLGF_PopupMenu)) &&
2361 Count < MaxCount &&
2362 (!(mle->llist_Flags & LLISTFLGF_MayNotHaveChildren) || (mle->llist_Flags & LLISTFLGF_PopupMenu));
2363
2364 MayAddCommand = (mle->llist_name && strlen(mle->llist_name) > 0) &&
2365 ((SCAMENUTYPE_MenuItem == mle->llist_EntryType)
2366 || (SCAMENUTYPE_Command == mle->llist_EntryType));
2367
2368 MayChangeName = (SCAMENUTYPE_Command != mle->llist_EntryType)
2369 && (SCAMENUTYPE_MainMenu != mle->llist_EntryType)
2370 && !(mle->llist_Flags & LLISTFLGF_NameNotSetable);
2371
2372 MayDelete = !(mle->llist_Flags & LLISTFLGF_NotRemovable);
2373
2374 MayHaveHotkey = (strlen(mle->llist_name) > 0)
2375 && SCAMENUTYPE_MenuItem == mle->llist_EntryType;
2376
2377 MayHaveImage = (mle->llist_name && strlen(mle->llist_name) > 0) &&
2378 IsPopupMenu(inst, TreeNode) &&
2379 (SCAMENUTYPE_Menu == mle->llist_EntryType
2380 || SCAMENUTYPE_MenuItem == mle->llist_EntryType);
2381
2382 if (SCAMENUTYPE_Command == mle->llist_EntryType)
2383 {
2384 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2385 MUIM_NListtree_GetEntry, TreeNode, MUIV_NListtree_GetEntry_Position_Parent, 0);
2386 }
2387
2388 // Cannot cut or copy entire main/tool/popup menus
2389 if ((SCAMENUTYPE_MainMenu == mle->llist_EntryType)
2390 || (SCAMENUTYPE_ToolsMenu == mle->llist_EntryType))
2391 {
2392 set(inst->mpb_Objects[OBJNDX_Menu_Copy], MUIA_Menuitem_Enabled, FALSE);
2393 set(inst->mpb_Objects[OBJNDX_Menu_Cut], MUIA_Menuitem_Enabled, FALSE);
2394 }
2395 else
2396 {
2397 set(inst->mpb_Objects[OBJNDX_Menu_Copy], MUIA_Menuitem_Enabled, TRUE);
2398 set(inst->mpb_Objects[OBJNDX_Menu_Cut], MUIA_Menuitem_Enabled, TRUE);
2399 }
2400
2401 d1(kprintf("%s/%s/%ld: tn_Name=%08lx\n", __FILE__, __FUNC__, __LINE__, TreeNode->tn_Name));
2402
2403 set(inst->mpb_Objects[OBJNDX_NameString], MUIA_String_Contents, (ULONG) TreeNode->tn_Name);
2404 set(inst->mpb_Objects[OBJNDX_StringHotkey], MUIA_String_Contents, (ULONG) mle->llist_HotKey);
2405 set(inst->mpb_Objects[OBJNDX_PopAsl_UnselectedImage], MUIA_String_Contents, (ULONG) mle->llist_UnselectedIconName);
2406 set(inst->mpb_Objects[OBJNDX_PopAsl_SelectedImage], MUIA_String_Contents, (ULONG) mle->llist_SelectedIconName);
2407 set(inst->mpb_Objects[OBJNDX_DtImage_UnselectedImage], MUIA_ScaDtpic_Name, (ULONG) mle->llist_UnselectedIconName);
2408 set(inst->mpb_Objects[OBJNDX_DtImage_SelectedImage], MUIA_ScaDtpic_Name, (ULONG) mle->llist_SelectedIconName);
2409
2410 set(inst->mpb_Objects[OBJNDX_DelButton], MUIA_Disabled, !MayDelete);
2411 set(inst->mpb_Objects[OBJNDX_NameString], MUIA_Disabled, !MayChangeName);
2412 set(inst->mpb_Objects[OBJNDX_NewItemButton], MUIA_Disabled, !MayAddNewItem);
2413 set(inst->mpb_Objects[OBJNDX_NewCommandButton], MUIA_Disabled, !MayAddCommand);
2414 set(inst->mpb_Objects[OBJNDX_NewMenuButton], MUIA_Disabled, !MayAddNewMenu);
2415 set(inst->mpb_Objects[OBJNDX_PopAsl_UnselectedImage], MUIA_Disabled, !MayHaveImage);
2416 set(inst->mpb_Objects[OBJNDX_PopAsl_SelectedImage], MUIA_Disabled, !MayHaveImage);
2417
2418 set(inst->mpb_Objects[OBJNDX_Menu_CollapseSelected], MUIA_Menuitem_Enabled, TRUE);
2419 set(inst->mpb_Objects[OBJNDX_Menu_ExpandSelected], MUIA_Menuitem_Enabled, TRUE);
2420
2421 set(inst->mpb_Objects[OBJNDX_StringHotkey], MUIA_Disabled, !MayHaveHotkey);
2422 set(inst->mpb_Objects[OBJNDX_Group_String], MUIA_Disabled, (SCAMENUTYPE_Command != mle->llist_EntryType));
2423 set(inst->mpb_Objects[OBJNDX_Group_CmdProperties], MUIA_Disabled, (SCAMENUTYPE_Command != mle->llist_EntryType));
2424
2425 tnShadow = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_ListTreeClipboard],
2426 MUIM_NListtree_GetEntry,
2427 MUIV_NListtree_Insert_ListNode_Root,
2428 MUIV_NListtree_GetEntry_Position_Head,
2429 0);
2430
2431 if (tnShadow)
2432 {
2433 if (MayPasteBelow(inst, TreeNode, tnShadow))
2434 {
2435 set(inst->mpb_Objects[OBJNDX_Menu_Paste], MUIA_Menuitem_Enabled, TRUE);
2436 }
2437 else if (MayPasteOnto(inst, TreeNode, tnShadow))
2438 {
2439 set(inst->mpb_Objects[OBJNDX_Menu_Paste], MUIA_Menuitem_Enabled, TRUE);
2440 }
2441 else
2442 {
2443 set(inst->mpb_Objects[OBJNDX_Menu_Paste], MUIA_Menuitem_Enabled, FALSE);
2444 }
2445 }
2446 else
2447 {
2448 set(inst->mpb_Objects[OBJNDX_Menu_Paste], MUIA_Menuitem_Enabled, FALSE);
2449 }
2450
2451 if (SCAMENUTYPE_Command == mle->llist_EntryType)
2452 {
2453 SwitchPopButton(inst, mle->llist_CommandType);
2454
2455 set(inst->mpb_Objects[OBJNDX_StringCmd], MUIA_String_Contents, (ULONG) mle->llist_name);
2456 set(inst->mpb_Objects[OBJNDX_StringStack], MUIA_String_Integer, (ULONG) mle->llist_Stack);
2457 set(inst->mpb_Objects[OBJNDX_SliderPriority], MUIA_Numeric_Value, (LONG) mle->llist_Priority);
2458 set(inst->mpb_Objects[OBJNDX_CycleGad], MUIA_Cycle_Active, (ULONG) mle->llist_CommandType);
2459
2460 }
2461 else
2462 {
2463 set(inst->mpb_Objects[OBJNDX_StringCmd], MUIA_String_Contents, (ULONG) "");
2464 }
2465
2466 EnableCommandArgumentGadgets(inst, mle);
2467 }
2468 }
2469 else
2470 {
2471 set(inst->mpb_Objects[OBJNDX_Menu_Copy], MUIA_Menuitem_Enabled, FALSE);
2472 set(inst->mpb_Objects[OBJNDX_Menu_Cut], MUIA_Menuitem_Enabled, FALSE);
2473 set(inst->mpb_Objects[OBJNDX_Menu_CollapseSelected], MUIA_Menuitem_Enabled, FALSE);
2474 set(inst->mpb_Objects[OBJNDX_Menu_ExpandSelected], MUIA_Menuitem_Enabled, FALSE);
2475
2476 set(inst->mpb_Objects[OBJNDX_NameString], MUIA_Disabled, TRUE);
2477 set(inst->mpb_Objects[OBJNDX_StringHotkey], MUIA_Disabled, TRUE);
2478 set(inst->mpb_Objects[OBJNDX_DelButton], MUIA_Disabled, TRUE);
2479 set(inst->mpb_Objects[OBJNDX_Group_String], MUIA_Disabled, TRUE);
2480 set(inst->mpb_Objects[OBJNDX_Group_CmdProperties], MUIA_Disabled, TRUE);
2481 set(inst->mpb_Objects[OBJNDX_PopAsl_UnselectedImage], MUIA_Disabled, TRUE);
2482 set(inst->mpb_Objects[OBJNDX_PopAsl_SelectedImage], MUIA_Disabled, TRUE);
2483 #if 0
2484 set(inst->mpb_Objects[OBJNDX_Menu_Paste], MUIA_Menuitem_Enabled, FALSE);
2485 #endif
2486 }
2487
2488 inst->mpb_QuietFlag = FALSE;
2489
2490 return 0;
2491 }
2492
2493 static SAVEDS(APTR) INTERRUPT PopButtonHookFunc(struct Hook *hook, Object *o, Msg msg)
2494 {
2495 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2496 struct MenuListEntry *mle;
2497 struct FileRequester *Req;
2498 struct MUI_NListtree_TreeNode *TreeNode;
2499 ULONG CommandType = 0;
2500
2501 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2502 MUIM_NListtree_GetEntry,
2503 MUIV_NListtree_GetEntry_ListNode_Active,
2504 MUIV_NListtree_GetEntry_Position_Active, 0);
2505 if (NULL == TreeNode)
2506 return 0;
2507
2508 get(inst->mpb_Objects[OBJNDX_CycleGad], MUIA_Cycle_Active, &CommandType);
2509
2510 mle = (struct MenuListEntry *) TreeNode->tn_User;
2511 Req = MUI_AllocAslRequest(ASL_FileRequest, NULL);
2512
2513 if (Req)
2514 {
2515 char FileName[512];
2516 struct Window *win = NULL;
2517 BOOL Result;
2518 STRPTR p, path = NULL;
2519 BOOL drawersOnly = FALSE;
2520 ULONG AslTitle = MSGID_IMPORTNAME;
2521
2522 get(inst->mpb_Objects[OBJNDX_StringCmd], MUIA_String_Contents, &path);
2523 get(inst->mpb_Objects[OBJNDX_WIN_Main], MUIA_Window_Window, &win);
2524
2525 switch (CommandType)
2526 {
2527 case SCAMENUCMDTYPE_AmigaDOS:
2528 AslTitle = MSGID_POPUP_ASLTITLE_AMIGADOS;
2529 break;
2530 case SCAMENUCMDTYPE_Workbench:
2531 AslTitle = MSGID_POPUP_ASLTITLE_WORKBENCH;
2532 break;
2533 case SCAMENUCMDTYPE_IconWindow:
2534 drawersOnly = TRUE;
2535 AslTitle = MSGID_POPUP_ASLTITLE_ICONWINDOW;
2536 break;
2537 case SCAMENUCMDTYPE_ARexx:
2538 AslTitle = MSGID_POPUP_ASLTITLE_AREXX;
2539 break;
2540 case SCAMENUCMDTYPE_Plugin:
2541 AslTitle = MSGID_POPUP_ASLTITLE_MENUPLUGIN;
2542 if (0 == strlen(path))
2543 strcpy(path, "scalos:Plugins/Menu/");
2544 break;
2545 default:
2546 break;
2547 }
2548
2549 if (drawersOnly)
2550 strcpy(FileName, "");
2551 else
2552 stccpy(FileName, FilePart(path), sizeof(FileName));
2553
2554 p = PathPart(path);
2555 *p = '\0';
2556
2557 d1(kprintf("%s/%s//%ld: InitialFile=<%s> InitialDrawer=<%s>\n", __FILE__, __FUNC__, __LINE__, FileName, path));
2558 d1(kprintf("%s/%s//%ld: DrawersOnly=%ld\n", __FILE__, __FUNC__, __LINE__, drawersOnly));
2559
2560 Result = MUI_AslRequestTags(Req,
2561 ASLFR_TitleText, GetLocString(MSGID_MENU_PROJECT_SAVEAS),
2562 ASLFR_Window, win,
2563 ASLFR_SleepWindow, TRUE,
2564 ASLFR_TitleText, GetLocString(AslTitle),
2565 ASLFR_Flags1, FRF_DOPATTERNS,
2566 ASLFR_InitialFile, FileName,
2567 ASLFR_InitialDrawer, path,
2568 ASLFR_DrawersOnly, drawersOnly,
2569 TAG_END);
2570
2571 if (Result)
2572 {
2573 struct DiskObject *icon;
2574
2575 SetChangedFlag(inst, TRUE);
2576
2577 d1(kprintf("%s/%s//%ld: fr_Drawer=<%s> fr_File=<%s>\n", __FILE__, __FUNC__, __LINE__, Req->fr_Drawer, Req->fr_File));
2578
2579 stccpy(FileName, Req->fr_Drawer, sizeof(FileName));
2580
2581 if (!drawersOnly)
2582 AddPart(FileName, Req->fr_File, sizeof(FileName));
2583
2584 d1(kprintf("%s/%s//%ld: FileName=<%s>\n", __FILE__, __FUNC__, __LINE__, FileName));
2585
2586 set(inst->mpb_Objects[OBJNDX_StringCmd], MUIA_String_Contents, (ULONG) FileName);
2587 stccpy(mle->llist_name, FileName, sizeof(mle->llist_name));
2588
2589 icon = GetDiskObject(FileName);
2590 if (icon)
2591 {
2592 STRPTR ToolString;
2593 ULONG ToolPri = 0;
2594
2595 get(inst->mpb_Objects[OBJNDX_SliderPriority], MUIA_Numeric_Value, &ToolPri);
2596 set(inst->mpb_Objects[OBJNDX_StringStack], MUIA_String_Integer, icon->do_StackSize);
2597
2598 ToolString = FindToolType(icon->do_ToolTypes, "TOOLPRI");
2599 if (ToolString)
2600 {
2601 long long1;
2602 sscanf(ToolString, "%ld", &long1);
2603 ToolPri = long1;
2604 }
2605
2606 set(inst->mpb_Objects[OBJNDX_SliderPriority], MUIA_Numeric_Value, (LONG) ToolPri);
2607
2608 FreeDiskObject(icon);
2609 }
2610
2611 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NList_Redraw, MUIV_NList_Redraw_Active);
2612 }
2613 }
2614
2615 return 0;
2616 }
2617
2618
2619 static SAVEDS(APTR) INTERRUPT AddMenuHookFunc(struct Hook *hook, Object *o, Msg msg)
2620 {
2621 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2622 struct MUI_NListtree_TreeNode *ParentNode;
2623 struct MUI_NListtree_TreeNode *PrevNode;
2624 struct MenuInsertEntry mie;
2625 struct ScalosMenuTree mTree;
2626
2627 memset(&mTree, 0, sizeof(mTree));
2628 mTree.mtre_type = SCAMENUTYPE_Menu;
2629 mie.mie_TreeEntry = &mTree;
2630 mie.mie_MenuFlags = 0;
2631
2632 SetChangedFlag(inst, TRUE);
2633
2634 ParentNode = GetParentNodeForMenu(inst, &PrevNode);
2635
2636 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2637 MUIM_NListtree_Insert, GetLocString(MSGID_NEW_MENU),
2638 &mie,
2639 ParentNode, PrevNode, MUIV_NListtree_Insert_Flag_Active | TNF_OPEN | TNF_LIST);
2640
2641 // try to activate menu name string gadget
2642 set(inst->mpb_Objects[OBJNDX_WIN_Main], MUIA_Window_ActiveObject,
2643 (ULONG) inst->mpb_Objects[OBJNDX_NameString]);
2644
2645 return 0;
2646 }
2647
2648
2649 static SAVEDS(APTR) INTERRUPT AddCommandHookFunc(struct Hook *hook, Object *o, Msg msg)
2650 {
2651 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2652 struct MUI_NListtree_TreeNode *ParentNode;
2653 struct MUI_NListtree_TreeNode *TreeNode;
2654
2655 SetChangedFlag(inst, TRUE);
2656
2657 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2658 MUIM_NListtree_GetEntry, 0, MUIV_NListtree_GetEntry_Position_Active, 0);
2659
2660 if (TreeNode)
2661 {
2662 struct MenuListEntry *mle = (struct MenuListEntry *) TreeNode->tn_User;
2663 struct MenuInsertEntry mie;
2664 struct ScalosMenuTree mTree;
2665
2666 memset(&mTree, 0, sizeof(mTree));
2667 mTree.mtre_type = SCAMENUTYPE_Command;
2668 mie.mie_TreeEntry = &mTree;
2669 mie.mie_MenuFlags = 0;
2670
2671 switch (mle->llist_EntryType)
2672 {
2673 case SCAMENUTYPE_MainMenu:
2674 case SCAMENUTYPE_Menu:
2675 case SCAMENUTYPE_ToolsMenu:
2676 break;
2677
2678 case SCAMENUTYPE_MenuItem:
2679 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2680 MUIM_NListtree_Insert, "",
2681 &mie,
2682 TreeNode, MUIV_NListtree_Insert_PrevNode_Tail,
2683 MUIV_NListtree_Insert_Flag_Active);
2684
2685 // try to activate command name string gadget
2686 set(inst->mpb_Objects[OBJNDX_WIN_Main], MUIA_Window_ActiveObject,
2687 (ULONG) inst->mpb_Objects[OBJNDX_StringCmd]);
2688 break;
2689
2690 case SCAMENUTYPE_Command:
2691 ParentNode = TreeNode;
2692
2693 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2694 MUIM_NListtree_GetEntry, TreeNode,
2695 MUIV_NListtree_GetEntry_Position_Parent, 0);
2696
2697 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2698 MUIM_NListtree_Insert, "",
2699 &mie,
2700 TreeNode, ParentNode,
2701 MUIV_NListtree_Insert_Flag_Active);
2702
2703 // try to activate command name string gadget
2704 set(inst->mpb_Objects[OBJNDX_WIN_Main], MUIA_Window_ActiveObject,
2705 (ULONG) inst->mpb_Objects[OBJNDX_StringCmd]);
2706 break;
2707 }
2708 }
2709
2710 return 0;
2711 }
2712
2713
2714 static SAVEDS(APTR) INTERRUPT AddMenuItemHookFunc(struct Hook *hook, Object *o, Msg msg)
2715 {
2716 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2717 struct MUI_NListtree_TreeNode *ParentNode;
2718 struct MUI_NListtree_TreeNode *PrevNode;
2719
2720 SetChangedFlag(inst, TRUE);
2721
2722 ParentNode = GetParentNodeForMenuItem(inst, &PrevNode);
2723
2724 if (ParentNode)
2725 {
2726 struct MUI_NListtree_TreeNode *newNode;
2727 struct MenuInsertEntry mie;
2728 struct ScalosMenuTree mTree;
2729
2730 memset(&mTree, 0, sizeof(mTree));
2731 mTree.mtre_type = SCAMENUTYPE_MenuItem;
2732 mie.mie_TreeEntry = &mTree;
2733 mie.mie_MenuFlags = 0;
2734
2735 newNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
2736 MUIM_NListtree_Insert, GetLocString(MSGID_NEW_ITEM),
2737 &mie,
2738 ParentNode, PrevNode,
2739 MUIV_NListtree_Insert_Flag_Active | TNF_OPEN | TNF_LIST);
2740
2741 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NListtree_GetNr,
2742 newNode, MUIV_NListtree_GetNr_Flag_CountLevel);
2743
2744 // try to activate menu name string gadget
2745 set(inst->mpb_Objects[OBJNDX_WIN_Main], MUIA_Window_ActiveObject,
2746 (ULONG) inst->mpb_Objects[OBJNDX_NameString]);
2747
2748 d1(kprintf("%s/%s/%ld: Node Count=%ld\n", __FILE__, __FUNC__, __LINE__, Count));
2749 }
2750
2751 return 0;
2752 }
2753
2754
2755 static SAVEDS(APTR) INTERRUPT RemoveEntryHookFunc(struct Hook *hook, Object *o, Msg msg)
2756 {
2757 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
2758
2759 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NListtree_Remove, MUIV_NListtree_Remove_ListNode_Active,
2760 MUIV_NListtree_Remove_TreeNode_Active, 0);
2761
2762 SetChangedFlag(inst, TRUE);
2763
2764 return 0;
2765 }
2766
2767 //----------------------------------------------------------------------------
2768
2769 static LONG ReadPrefsFile(struct MenuPrefsInst *inst, CONST_STRPTR Filename, BOOL Quiet)
2770 {
2771 LONG Result;
2772 struct IFFHandle *iff;
2773 BOOL iffOpened = FALSE;
2774 struct ScalosMenuChunk *menuChunk = NULL;
2775
2776 set(inst->mpb_Objects[OBJNDX_MainListView], MUIA_NListtree_Quiet, TRUE);
2777
2778 d1(kprintf("%s/%s//%ld: LocaleBase=%08lx IFFParseBase=%08lx\n", __FILE__, __FUNC__, __LINE__, LocaleBase, IFFParseBase));
2779
2780 do {
2781 iff = AllocIFF();
2782 if (NULL == iff)
2783 {
2784 Result = IoErr();
2785 break;
2786 }
2787
2788 InitIFFasDOS(iff);
2789
2790 iff->iff_Stream = (IPTR)Open(Filename, MODE_OLDFILE);
2791 if (0 == iff->iff_Stream)
2792 {
2793 Result = IoErr();
2794 break;
2795 }
2796
2797 Result = OpenIFF(iff, IFFF_READ);
2798 if (RETURN_OK != Result)
2799 break;
2800
2801 iffOpened = TRUE;
2802
2803 Result = StopChunks(iff, StopChunkList, 2);
2804 if (RETURN_OK != Result)
2805 break;
2806
2807 while (1)
2808 {
2809 struct ContextNode *cn;
2810
2811 Result = ParseIFF(iff, IFFPARSE_SCAN);
2812 d1(kprintf("%s/%s/%ld: Result=%ld\n", __FILE__, __FUNC__, __LINE__, Result));
2813 if (RETURN_OK != Result)
2814 break;
2815
2816 cn = CurrentChunk(iff);
2817
2818 d1(kprintf("%s/%s//%ld: cn=%08lx\n", __FILE__, __FUNC__, __LINE__, cn));
2819 if (NULL == cn)
2820 break;
2821
2822 if (ID_MENU == cn->cn_ID)
2823 {
2824 LONG Actual;
2825
2826 menuChunk = malloc(cn->cn_Size);
2827
2828 d1(kprintf("%s/%s//%ld: menuChunk=%08lx\n", __FILE__, __FUNC__, __LINE__, menuChunk));
2829 if (NULL == menuChunk)
2830 break;
2831
2832 Actual = ReadChunkBytes(iff, menuChunk, cn->cn_Size);
2833 if (Actual != cn->cn_Size)
2834 break;
2835
2836 menuChunk->smch_MenuID = SCA_BE2WORD(menuChunk->smch_MenuID);
2837 menuChunk->smch_Entries = SCA_BE2WORD(menuChunk->smch_Entries);
2838
2839 d1(kprintf("%s/%s/%ld: MenuID=%ld Entries=%ld\n", \
2840 __FILE__, __FUNC__, __LINE__, menuChunk->smch_MenuID, menuChunk->smch_Entries));
2841
2842 AddAddresses(menuChunk->smch_Menu, (UBYTE *) menuChunk);
2843
2844 switch (menuChunk->smch_MenuID)
2845 {
2846 case SCMID_MainMenu:
2847 GenerateMenuList(inst, menuChunk->smch_Menu,
2848 inst->mpb_MainMenuNode.mpn_Listtree,
2849 inst->mpb_MainMenuNode.mpn_ListNode);
2850 break;
2851 case SCMID_Popup_Disk:
2852 GenerateMenuList(inst, menuChunk->smch_Menu,
2853 inst->mpb_PopMenuNode[POPMENUINDEX_Disk].mpn_Listtree,
2854 inst->mpb_PopMenuNode[POPMENUINDEX_Disk].mpn_ListNode);
2855 break;
2856 case SCMID_Popup_Drawer:
2857 GenerateMenuList(inst, menuChunk->smch_Menu,
2858 inst->mpb_PopMenuNode[POPMENUINDEX_Drawer].mpn_Listtree,
2859 inst->mpb_PopMenuNode[POPMENUINDEX_Drawer].mpn_ListNode);
2860 break;
2861 case SCMID_Popup_Tool:
2862 GenerateMenuList(inst, menuChunk->smch_Menu,
2863 inst->mpb_PopMenuNode[POPMENUINDEX_ToolProject].mpn_Listtree,
2864 inst->mpb_PopMenuNode[POPMENUINDEX_ToolProject].mpn_ListNode);
2865 break;
2866 case SCMID_Popup_Trashcan:
2867 GenerateMenuList(inst, menuChunk->smch_Menu,
2868 inst->mpb_PopMenuNode[POPMENUINDEX_Trashcan].mpn_Listtree,
2869 inst->mpb_PopMenuNode[POPMENUINDEX_Trashcan].mpn_ListNode);
2870 break;
2871 case SCMID_Popup_Window:
2872 GenerateMenuList(inst, menuChunk->smch_Menu,
2873 inst->mpb_PopMenuNode[POPMENUINDEX_Window].mpn_Listtree,
2874 inst->mpb_PopMenuNode[POPMENUINDEX_Window].mpn_ListNode);
2875 break;
2876 case SCMID_Popup_AppIcon:
2877 GenerateMenuList(inst, menuChunk->smch_Menu,
2878 inst->mpb_PopMenuNode[POPMENUINDEX_AppIcon].mpn_Listtree,
2879 inst->mpb_PopMenuNode[POPMENUINDEX_AppIcon].mpn_ListNode);
2880 break;
2881 case SCMID_Popup_Desktop:
2882 GenerateMenuList(inst, menuChunk->smch_Menu,
2883 inst->mpb_PopMenuNode[POPMENUINDEX_Desktop].mpn_Listtree,
2884 inst->mpb_PopMenuNode[POPMENUINDEX_Desktop].mpn_ListNode);
2885 break;
2886 }
2887
2888 free(menuChunk);
2889 menuChunk = NULL;
2890 }
2891 }
2892
2893 d1(kprintf("%s/%s/%ld: Result=%ld\n", __FILE__, __FUNC__, __LINE__, Result));
2894 if (IFFERR_EOF == Result)
2895 Result = RETURN_OK;
2896 } while (0);
2897
2898 set(inst->mpb_Objects[OBJNDX_MainListView], MUIA_NListtree_Quiet, FALSE);
2899
2900 if (menuChunk)
2901 free(menuChunk);
2902
2903 if (iff)
2904 {
2905 if (iffOpened)
2906 CloseIFF(iff);
2907
2908 if (iff->iff_Stream)
2909 Close((BPTR)iff->iff_Stream);
2910
2911 FreeIFF(iff);
2912 }
2913
2914 if (RETURN_OK != Result && !Quiet)
2915 {
2916 char Buffer[120];
2917
2918 Fault(Result, "", Buffer, sizeof(Buffer) - 1);
2919
2920 // MUI_RequestA()
2921 MUI_Request(inst->mpb_Objects[OBJNDX_APP_Main], inst->mpb_Objects[OBJNDX_WIN_Main], 0, NULL,
2922 GetLocString(MSGID_ABOUTREQOK),
2923 GetLocString(MSGID_REQTITLE_READERROR),
2924 Filename,
2925 Buffer);
2926 }
2927
2928 // DoMethod(ScalosPenList, MUIM_NList_Redraw, MUIV_NList_Redraw_All);
2929
2930 d1(kprintf("%s/%s/%ld: Result=%ld\n", __FILE__, __FUNC__, __LINE__, Result));
2931
2932 return Result;
2933 }
2934
2935
2936 static LONG WritePrefsFile(struct MenuPrefsInst *inst, CONST_STRPTR Filename)
2937 {
2938 struct IFFHandle *iff;
2939 LONG Result;
2940 BOOL IffOpen = FALSE;
2941
2942 do {
2943 static const struct PrefHeader prefHeader = { 1, 0, 0L };
2944
2945 iff = AllocIFF();
2946 if (NULL == iff)
2947 {
2948 Result = IoErr();
2949 break;
2950 }
2951
2952 InitIFFasDOS(iff);
2953
2954 iff->iff_Stream = (IPTR)Open(Filename, MODE_NEWFILE);
2955 if (0 == iff->iff_Stream)
2956 {
2957 // ... try to create missing directories here
2958 STRPTR FilenameCopy;
2959
2960 Result = IoErr();
2961 d1(kprintf("%s/%s/%ld: Result=%ld\n", __FILE__, __FUNC__, __LINE__, Result));
2962
2963 FilenameCopy = AllocVec(1 + strlen(Filename), MEMF_PUBLIC);
2964
2965 if (FilenameCopy)
2966 {
2967 STRPTR lp;
2968
2969 strcpy(FilenameCopy, Filename);
2970
2971 lp = PathPart(FilenameCopy);
2972 if (lp)
2973 {
2974 BPTR dirLock;
2975
2976 *lp = '\0';
2977 dirLock = CreateDir(FilenameCopy);
2978
2979 if (dirLock)
2980 UnLock(dirLock);
2981
2982 iff->iff_Stream = (IPTR)Open(Filename, MODE_NEWFILE);
2983 if (0 == iff->iff_Stream)
2984 Result = IoErr();
2985 else
2986 Result = RETURN_OK;
2987 }
2988
2989 FreeVec(FilenameCopy);
2990 }
2991
2992 d1(kprintf("%s/%s/%ld: Result=%ld\n", __FILE__, __FUNC__, __LINE__, Result));
2993 if (RETURN_OK != Result)
2994 break;
2995 }
2996
2997 Result = OpenIFF(iff, IFFF_WRITE);
2998 if (RETURN_OK != Result)
2999 break;
3000
3001 IffOpen = TRUE;
3002
3003 Result = PushChunk(iff, ID_PREF, ID_FORM, IFFSIZE_UNKNOWN);
3004 if (RETURN_OK != Result)
3005 break;
3006
3007 Result = PushChunk(iff, 0, ID_PRHD, IFFSIZE_UNKNOWN);
3008 if (RETURN_OK != Result)
3009 break;
3010
3011 if (WriteChunkBytes(iff, (APTR) &prefHeader, sizeof(prefHeader)) < 0)
3012 {
3013 Result = IoErr();
3014 break;
3015 }
3016
3017 Result = PopChunk(iff);
3018 if (RETURN_OK != Result)
3019 break;
3020
3021 Result = SaveMenuNode(inst,
3022 iff, &inst->mpb_MainMenuNode, SCMID_MainMenu);
3023 if (RETURN_OK != Result)
3024 break;
3025
3026 Result = SaveMenuNode(inst,
3027 iff, &inst->mpb_PopMenuNode[POPMENUINDEX_Disk], SCMID_Popup_Disk);
3028 if (RETURN_OK != Result)
3029 break;
3030
3031 Result = SaveMenuNode(inst,
3032 iff, &inst->mpb_PopMenuNode[POPMENUINDEX_Drawer], SCMID_Popup_Drawer);
3033 if (RETURN_OK != Result)
3034 break;
3035
3036 Result = SaveMenuNode(inst,
3037 iff, &inst->mpb_PopMenuNode[POPMENUINDEX_ToolProject], SCMID_Popup_Tool);
3038 if (RETURN_OK != Result)
3039 break;
3040
3041 Result = SaveMenuNode(inst,
3042 iff, &inst->mpb_PopMenuNode[POPMENUINDEX_Trashcan], SCMID_Popup_Trashcan);
3043 if (RETURN_OK != Result)
3044 break;
3045
3046 Result = SaveMenuNode(inst,
3047 iff, &inst->mpb_PopMenuNode[POPMENUINDEX_Window], SCMID_Popup_Window);
3048 if (RETURN_OK != Result)
3049 break;
3050
3051 Result = SaveMenuNode(inst,
3052 iff, &inst->mpb_PopMenuNode[POPMENUINDEX_AppIcon], SCMID_Popup_AppIcon);
3053 if (RETURN_OK != Result)
3054 break;
3055
3056 Result = SaveMenuNode(inst,
3057 iff, &inst->mpb_PopMenuNode[POPMENUINDEX_Desktop], SCMID_Popup_Desktop);
3058 if (RETURN_OK != Result)
3059 break;
3060
3061 Result = PopChunk(iff);
3062 if (RETURN_OK != Result)
3063 break;
3064
3065 } while (0);
3066
3067 if (iff)
3068 {
3069 if (IffOpen)
3070 CloseIFF(iff);
3071
3072 if (iff->iff_Stream)
3073 {
3074 Close((BPTR)iff->iff_Stream);
3075 iff->iff_Stream = 0;
3076 }
3077
3078 FreeIFF(iff);
3079 }
3080
3081 if (RETURN_OK == Result)
3082 {
3083 if (inst->mpb_fCreateIcons)
3084 SaveIcon(inst, Filename);
3085 }
3086 else
3087 {
3088 char Buffer[120];
3089
3090 Fault(Result, "", Buffer, sizeof(Buffer) - 1);
3091
3092 // MUI_RequestA()
3093 MUI_Request(inst->mpb_Objects[OBJNDX_APP_Main], inst->mpb_Objects[OBJNDX_WIN_Main], 0, NULL,
3094 GetLocString(MSGID_ABOUTREQOK),
3095 GetLocString(MSGID_REQTITLE_SAVEERROR),
3096 Filename,
3097 Buffer);
3098 }
3099
3100 return Result;
3101 }
3102
3103
3104 static LONG SaveMenuNode(struct MenuPrefsInst *inst, struct IFFHandle *iff,
3105 const struct MenuPrefsPopMenuNode *TreeNode, enum ScalosMenuChunkId ChunkID)
3106 {
3107 LONG Result;
3108 struct ScalosMenuChunk *mChunk = NULL;
3109
3110 do {
3111 const struct MUI_NListtree_TreeNode *SubNode;
3112 size_t StringSpaceSize = 0;
3113 STRPTR StringSpace;
3114 UWORD nodeCount;
3115 size_t Length;
3116 struct ScalosMenuTree *MenuTreeSpace;
3117
3118 SubNode = (const struct MUI_NListtree_TreeNode *) DoMethod(TreeNode->mpn_Listtree,
3119 MUIM_NListtree_GetEntry, TreeNode->mpn_ListNode,
3120 MUIV_NListtree_GetEntry_Position_Head,
3121 0);
3122 if(NULL == SubNode)
3123 {
3124 Result = RETURN_OK;
3125 break;
3126 }
3127
3128 nodeCount = CountMenuEntries(inst, TreeNode->mpn_Listtree, SubNode, &StringSpaceSize);
3129
3130 Length = sizeof(struct ScalosMenuChunk) + (nodeCount * sizeof(struct ScalosMenuChunk)) + StringSpaceSize;
3131
3132 mChunk = calloc(1, Length);
3133 if (NULL == mChunk)
3134 {
3135 Result = ERROR_NO_FREE_STORE;
3136 break;
3137 }
3138
3139 d1(kprintf("%s/%s/%ld: mChunk=%08lx Length=%lu\n", __FILE__, __FUNC__, __LINE__, mChunk, Length));
3140
3141 StringSpace = (STRPTR) &mChunk->smch_Menu[nodeCount];
3142
3143 mChunk->smch_MenuID = SCA_WORD2BE(ChunkID);
3144 mChunk->smch_Entries = SCA_WORD2BE(nodeCount);
3145
3146 d1(kprintf("%s/%s/%ld: ChunkID=%ld Count=%ld StringSpaceSize=%lu\n", \
3147 __FILE__, __FUNC__, __LINE__, mChunk->smch_MenuID, mChunk->smch_Entries, StringSpaceSize));
3148
3149 MenuTreeSpace = mChunk->smch_Menu;
3150
3151 Result = BuildMenuTree(inst, TreeNode->mpn_Listtree, SubNode, &MenuTreeSpace, &StringSpace, NULL);
3152 if (RETURN_OK != Result)
3153 break;
3154
3155 RemoveAddresses(mChunk->smch_Menu, (UBYTE *) mChunk);
3156
3157 Result = PushChunk(iff, 0, ID_MENU, IFFSIZE_UNKNOWN);
3158 if (RETURN_OK != Result)
3159 break;
3160
3161 if (Length != WriteChunkBytes(iff, (APTR) mChunk, Length))
3162 {
3163 Result = IoErr();
3164 break;
3165 }
3166
3167 Result = PopChunk(iff);
3168 if (RETURN_OK != Result)
3169 break;
3170 } while (0);
3171
3172 if (mChunk)
3173 free(mChunk);
3174
3175 return Result;
3176 }
3177
3178
3179 static UWORD CountMenuEntries(struct MenuPrefsInst *inst, Object *ListTree,
3180 const struct MUI_NListtree_TreeNode *TreeNode, size_t *StringSpace)
3181 {
3182 UWORD Count = 0;
3183
3184 while (TreeNode)
3185 {
3186 const struct MUI_NListtree_TreeNode *SubNode;
3187 const struct MenuListEntry *mle = (struct MenuListEntry *) TreeNode->tn_User;
3188
3189 d1(kprintf("%s/%s/%ld: TreeNode=%08lx <%s>\n", \
3190 __FILE__, __FUNC__, __LINE__, TreeNode, TreeNode->tn_Name));
3191
3192 Count++;
3193
3194 *StringSpace += 1 + strlen(mle->llist_name);
3195
3196 if (strlen(mle->llist_UnselectedIconName) > 0
3197 || strlen(mle->llist_SelectedIconName) > 0)
3198 {
3199 *StringSpace += 1 + strlen(mle->llist_UnselectedIconName)
3200 + 1 + strlen(mle->llist_SelectedIconName);
3201 }
3202
3203 SubNode = (const struct MUI_NListtree_TreeNode *) DoMethod(ListTree,
3204 MUIM_NListtree_GetEntry, TreeNode, MUIV_NListtree_GetEntry_Position_Head,
3205 0);
3206
3207 if (SubNode)
3208 Count += CountMenuEntries(inst, ListTree, SubNode, StringSpace);
3209
3210 TreeNode = (const struct MUI_NListtree_TreeNode *) DoMethod(ListTree,
3211 MUIM_NListtree_GetEntry, TreeNode, MUIV_NListtree_GetEntry_Position_Next,
3212 MUIV_NListtree_GetEntry_Flag_SameLevel);
3213 }
3214
3215 return Count;
3216 }
3217
3218
3219 static LONG BuildMenuTree(struct MenuPrefsInst *inst, Object *ListTree,
3220 const struct MUI_NListtree_TreeNode *TreeNode,
3221 struct ScalosMenuTree **MenuSpace, STRPTR *StringSpace,
3222 struct ScalosMenuTree **Parent)
3223 {
3224 LONG Result = RETURN_OK;
3225
3226 while (TreeNode)
3227 {
3228 struct ScalosMenuTree *mTree = *(struct ScalosMenuTree **) MenuSpace;
3229 const struct MUI_NListtree_TreeNode *SubNode;
3230 const struct MenuListEntry *mle = (struct MenuListEntry *) TreeNode->tn_User;
3231 STRPTR MenuName;
3232
3233 d1(KPrintF("%s/%s/%ld: TreeNode=%08lx <%s> mTree=%08lx\n", \
3234 __FILE__, __FUNC__, __LINE__, TreeNode, TreeNode->tn_Name ? TreeNode->tn_Name : (STRPTR) "===BAR===", mTree));
3235
3236 if (Parent)
3237 *Parent = mTree;
3238
3239 mTree->mtre_Next = NULL;
3240 mTree->mtre_tree = NULL;
3241
3242 mTree->mtre_type = mle->llist_EntryType;
3243 mTree->mtre_flags = mle->llist_Flags;
3244
3245 if (strlen(mle->llist_name) > 0)
3246 {
3247 MenuName = AddMenuString(mle->llist_name, StringSpace);
3248 }
3249 else
3250 {
3251 MenuName = NULL;
3252 }
3253
3254 *MenuSpace = mTree + 1;
3255
3256 if (SCAMENUTYPE_Command == mTree->mtre_type)
3257 {
3258 mTree->MenuCombo.MenuCommand.mcom_flags = mle->llist_CommandFlags;
3259 mTree->MenuCombo.MenuCommand.mcom_type = mle->llist_CommandType;
3260 mTree->MenuCombo.MenuCommand.mcom_stack = mle->llist_Stack;
3261 mTree->MenuCombo.MenuCommand.mcom_pri = mle->llist_Priority;
3262 mTree->MenuCombo.MenuCommand.mcom_name = MenuName;
3263 }
3264 else
3265 {
3266 if (strlen(mle->llist_UnselectedIconName) > 0
3267 || strlen(mle->llist_SelectedIconName) > 0)
3268 {
3269 STRPTR IconName;
3270
3271 IconName = AddMenuString(mle->llist_UnselectedIconName, StringSpace);
3272 AddMenuString(mle->llist_SelectedIconName, StringSpace);
3273 mTree->MenuCombo.MenuTree.mtre_iconnames = IconName;
3274
3275 mTree->mtre_flags |= MTREFLGF_IconNames;
3276 }
3277 else
3278 {
3279 mTree->MenuCombo.MenuTree.mtre_iconnames = NULL;
3280 mTree->mtre_flags &= ~MTREFLGF_IconNames;
3281 }
3282
3283 d1(KPrintF("%s/%s/%ld: mtre_name=<%s> mtre_flags=%02lx mtre_iconnames=%08lx\n", \
3284 __FILE__, __FUNC__, __LINE__, mTree->MenuCombo.MenuTree.mtre_name, \
3285 mTree->mtre_flags, mTree->MenuCombo.MenuTree.mtre_iconnames));
3286
3287 stccpy(mTree->MenuCombo.MenuTree.mtre_hotkey, mle->llist_HotKey,
3288 sizeof(mTree->MenuCombo.MenuTree.mtre_hotkey));
3289 mTree->MenuCombo.MenuTree.mtre_name = MenuName;
3290 }
3291
3292 SubNode = (const struct MUI_NListtree_TreeNode *) DoMethod(ListTree,
3293 MUIM_NListtree_GetEntry, TreeNode, MUIV_NListtree_GetEntry_Position_Head,
3294 0);
3295
3296 if (SubNode)
3297 {
3298 Result = BuildMenuTree(inst, ListTree, SubNode, MenuSpace, StringSpace, &mTree->mtre_tree);
3299 if (RETURN_OK != Result)
3300 break;
3301 }
3302
3303 TreeNode = (const struct MUI_NListtree_TreeNode *) DoMethod(ListTree,
3304 MUIM_NListtree_GetEntry, TreeNode, MUIV_NListtree_GetEntry_Position_Next,
3305 MUIV_NListtree_GetEntry_Flag_SameLevel);
3306
3307 if (TreeNode)
3308 Parent = &mTree->mtre_Next;
3309 }
3310
3311 return Result;
3312 }
3313
3314
3315 static STRPTR AddMenuString(CONST_STRPTR MenuString, STRPTR *StringSpace)
3316 {
3317 STRPTR MenuName = *StringSpace;
3318
3319 strcpy(MenuName, MenuString);
3320 *StringSpace = (APTR) (MenuName + 1 + strlen(MenuName));
3321
3322 return MenuName;
3323 }
3324
3325
3326 static void RemoveAddresses(struct ScalosMenuTree *MenuTree, const UBYTE *BaseAddr)
3327 {
3328 while (MenuTree)
3329 {
3330 struct ScalosMenuTree *MenuTreeNext = MenuTree->mtre_Next;
3331
3332 if (SCAMENUTYPE_Command == MenuTree->mtre_type)
3333 {
3334 if (MenuTree->MenuCombo.MenuCommand.mcom_name)
3335 {
3336 MenuTree->MenuCombo.MenuCommand.mcom_name -= (ULONG) BaseAddr;
3337 MenuTree->MenuCombo.MenuCommand.mcom_name = (APTR) SCA_LONG2BE(MenuTree->MenuCombo.MenuCommand.mcom_name);
3338 }
3339 MenuTree->MenuCombo.MenuCommand.mcom_stack = SCA_LONG2BE(MenuTree->MenuCombo.MenuCommand.mcom_stack);
3340 }
3341 else
3342 {
3343 if (MenuTree->MenuCombo.MenuTree.mtre_name)
3344 {
3345 MenuTree->MenuCombo.MenuTree.mtre_name -= (ULONG) BaseAddr;
3346 MenuTree->MenuCombo.MenuTree.mtre_name = (APTR) SCA_LONG2BE(MenuTree->MenuCombo.MenuTree.mtre_name);
3347 }
3348
3349 if ((MenuTree->mtre_flags & MTREFLGF_IconNames) && MenuTree->MenuCombo.MenuTree.mtre_iconnames)
3350 {
3351 MenuTree->MenuCombo.MenuTree.mtre_iconnames -= (ULONG) BaseAddr;
3352 MenuTree->MenuCombo.MenuTree.mtre_iconnames = (APTR) SCA_LONG2BE(MenuTree->MenuCombo.MenuTree.mtre_iconnames);
3353 }
3354
3355 d1(KPrintF("%s/%s/%ld: mtre_name=<%s> mtre_flags=%02lx mtre_iconnames=%08lx\n", \
3356 __FILE__, __FUNC__, __LINE__, MenuTree->MenuCombo.MenuTree.mtre_name, \
3357 MenuTree->mtre_flags, MenuTree->MenuCombo.MenuTree.mtre_iconnames));
3358 }
3359 if (MenuTree->mtre_tree)
3360 {
3361 RemoveAddresses(MenuTree->mtre_tree, BaseAddr);
3362 MenuTree->mtre_tree = (struct ScalosMenuTree *) (((UBYTE *) MenuTree->mtre_tree) - (ULONG) BaseAddr);
3363 MenuTree->mtre_tree = (APTR)SCA_LONG2BE(MenuTree->mtre_tree);
3364 }
3365 if (MenuTree->mtre_Next)
3366 {
3367 MenuTree->mtre_Next = (struct ScalosMenuTree *) (((UBYTE *) MenuTree->mtre_Next) - (ULONG) BaseAddr);
3368 MenuTree->mtre_Next = (APTR)SCA_LONG2BE(MenuTree->mtre_Next);
3369 }
3370
3371 MenuTree = MenuTreeNext;
3372 }
3373 }
3374
3375
3376 static LONG SaveIcon(struct MenuPrefsInst *inst, CONST_STRPTR IconName)
3377 {
3378 struct DiskObject *icon, *allocIcon;
3379
3380 static UBYTE ImageData[] =
3381 {
3382 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
3383 0x00, 0x00, 0x07, 0xFF, 0x80, 0x00, 0x40, 0x00, 0x00, 0x00, 0x18, 0x00, 0x60, 0x00, 0x10, 0x00,
3384 0x00, 0x00, 0x20, 0xFC, 0x10, 0x00, 0x08, 0x00, 0x00, 0x00, 0x41, 0x02, 0x08, 0x00, 0x0C, 0x00,
3385 0x00, 0x00, 0x40, 0x82, 0x08, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x40, 0x82, 0x08, 0x00, 0x0C, 0x00,
3386 0x00, 0x00, 0x21, 0x04, 0x08, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x1E, 0x18, 0x10, 0x00, 0x0C, 0x00,
3387 0x00, 0x00, 0x00, 0x60, 0x20, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0x80, 0xC0, 0x00, 0x0C, 0x00,
3388 0x00, 0x00, 0x01, 0x03, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x02, 0x1C, 0x00, 0x00, 0x0C, 0x00,
3389 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x0C, 0x00,
3390 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x0C, 0x00, 0x00, 0x00, 0x01, 0x08, 0x00, 0x00, 0x0C, 0x00,
3391 0x40, 0x00, 0x00, 0xF0, 0x00, 0x00, 0x0C, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00,
3392 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0C, 0x00, 0x01, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0x00,
3393 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xF8, 0x00, 0x00,
3394 0xD5, 0x55, 0x55, 0x55, 0x55, 0x56, 0x00, 0x00, 0xD5, 0x55, 0x50, 0x00, 0x55, 0x55, 0x80, 0x00,
3395 0xD5, 0x55, 0x47, 0xFF, 0x95, 0x55, 0x60, 0x00, 0xD5, 0x55, 0x5F, 0x03, 0xE5, 0x55, 0x50, 0x00,
3396 0xD5, 0x55, 0x3E, 0x55, 0xF5, 0x55, 0x50, 0x00, 0xD5, 0x55, 0x3F, 0x55, 0xF5, 0x55, 0x50, 0x00,
3397 0xD5, 0x55, 0x3F, 0x55, 0xF5, 0x55, 0x50, 0x00, 0xD5, 0x55, 0x5E, 0x53, 0xF5, 0x55, 0x50, 0x00,
3398 0xD5, 0x55, 0x41, 0x47, 0xE5, 0x55, 0x50, 0x00, 0xD5, 0x55, 0x55, 0x1F, 0xD5, 0x55, 0x50, 0x00,
3399 0xD5, 0x55, 0x55, 0x7F, 0x15, 0x55, 0x50, 0x00, 0xD5, 0x55, 0x54, 0xFC, 0x55, 0x55, 0x50, 0x00,
3400 0xD5, 0x55, 0x55, 0xE1, 0x55, 0x55, 0x50, 0x00, 0xD5, 0x55, 0x54, 0xF5, 0x55, 0x55, 0x50, 0x00,
3401 0xD5, 0x55, 0x55, 0x05, 0x55, 0x55, 0x50, 0x00, 0xD5, 0x55, 0x54, 0xF5, 0x55, 0x55, 0x50, 0x00,
3402 0xD5, 0x55, 0x54, 0xF5, 0x55, 0x55, 0x50, 0x00, 0x35, 0x55, 0x55, 0x05, 0x55, 0x55, 0x50, 0x00,
3403 0x0D, 0x55, 0x55, 0x55, 0x55, 0x55, 0x50, 0x00, 0x03, 0x55, 0x55, 0x55, 0x55, 0x55, 0x50, 0x00,
3404 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
3405 };
3406
3407 static struct Image NormalImage =
3408 {
3409 0, 0, 54, 23,
3410 2,
3411 (UWORD *)ImageData,
3412 3, 0,
3413 NULL
3414 };
3415
3416 static STRPTR defToolTypes[] =
3417 {
3418 "ACTION=USE",
3419 NULL
3420 };
3421
3422 static struct DiskObject DefaultIcon =
3423 {
3424 WB_DISKMAGIC, WB_DISKVERSION,
3425
3426 {
3427 NULL,
3428 0, 0, 54, 24,
3429 GFLG_GADGIMAGE | GFLG_GADGHBOX,
3430 GACT_RELVERIFY | GACT_IMMEDIATE,
3431 GTYP_BOOLGADGET,
3432 &NormalImage, NULL,
3433 NULL,
3434 0,
3435 NULL,
3436 0,
3437 NULL
3438 },
3439
3440 WBPROJECT,
3441 NULL,
3442 defToolTypes,
3443 NO_ICON_POSITION, NO_ICON_POSITION,
3444 NULL,
3445 NULL,
3446 8192
3447 };
3448
3449 icon = allocIcon = GetDiskObject("ENV:sys/def_ScaMenuPrefs");
3450 if (NULL == icon)
3451 icon = allocIcon = GetDiskObject("ENV:sys/def_pref");
3452 if (NULL == icon)
3453 icon = &DefaultIcon;
3454
3455 if (icon)
3456 {
3457 STRPTR oldDefaultTool = icon->do_DefaultTool;
3458
3459 icon->do_DefaultTool = (STRPTR) inst->mpb_ProgramName;
3460
3461 PutDiskObject((STRPTR) IconName, icon);
3462
3463 icon->do_DefaultTool = oldDefaultTool;
3464
3465 if (allocIcon)
3466 FreeDiskObject(allocIcon);
3467 }
3468
3469 return 0;
3470 }
3471
3472
3473 static void ClearMenuList(struct MenuPrefsInst *inst)
3474 {
3475 short n;
3476
3477 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, TRUE);
3478
3479 DoMethod(inst->mpb_MainMenuNode.mpn_Listtree, MUIM_NListtree_Remove,
3480 inst->mpb_MainMenuNode.mpn_ListNode, MUIV_NListtree_Remove_TreeNode_All, 0);
3481
3482 for (n=0; n<Sizeof(inst->mpb_PopMenuNode); n++)
3483 {
3484 DoMethod(inst->mpb_PopMenuNode[n].mpn_Listtree, MUIM_NListtree_Remove,
3485 inst->mpb_PopMenuNode[n].mpn_ListNode,
3486 MUIV_NListtree_Remove_TreeNode_All, 0);
3487 }
3488
3489 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, FALSE);
3490 }
3491
3492
3493 static void AddAddresses(struct ScalosMenuTree *MenuTree, const UBYTE *BaseAddr)
3494 {
3495 while (MenuTree)
3496 {
3497 if (SCAMENUTYPE_Command == MenuTree->mtre_type)
3498 {
3499 MenuTree->MenuCombo.MenuCommand.mcom_name = (APTR) SCA_BE2LONG(MenuTree->MenuCombo.MenuCommand.mcom_name);
3500 if (MenuTree->MenuCombo.MenuCommand.mcom_name)
3501 MenuTree->MenuCombo.MenuCommand.mcom_name += (ULONG) BaseAddr;
3502 MenuTree->MenuCombo.MenuCommand.mcom_stack = SCA_BE2LONG(MenuTree->MenuCombo.MenuCommand.mcom_stack);
3503 }
3504 else
3505 {
3506 MenuTree->MenuCombo.MenuTree.mtre_name = (APTR) SCA_BE2LONG(MenuTree->MenuCombo.MenuTree.mtre_name);
3507 if (MenuTree->MenuCombo.MenuTree.mtre_name)
3508 MenuTree->MenuCombo.MenuTree.mtre_name += (ULONG) BaseAddr;
3509
3510 if (MenuTree->mtre_flags & MTREFLGF_IconNames)
3511 {
3512 MenuTree->MenuCombo.MenuTree.mtre_iconnames = (APTR) SCA_BE2LONG(MenuTree->MenuCombo.MenuTree.mtre_iconnames);
3513 if (MenuTree->MenuCombo.MenuTree.mtre_iconnames)
3514 {
3515 MenuTree->MenuCombo.MenuTree.mtre_iconnames += (ULONG) BaseAddr;
3516 }
3517 else
3518 {
3519 MenuTree->MenuCombo.MenuTree.mtre_iconnames = NULL;
3520 }
3521 }
3522 else
3523 {
3524 MenuTree->MenuCombo.MenuTree.mtre_iconnames = NULL;
3525 }
3526
3527 d1(KPrintF("%s/%s/%ld: mtre_name=<%s> mtre_flags=%02lx mtre_iconnames=%08lx\n", \
3528 __FILE__, __FUNC__, __LINE__, MenuTree->MenuCombo.MenuTree.mtre_name, \
3529 MenuTree->mtre_flags, MenuTree->MenuCombo.MenuTree.mtre_iconnames));
3530 d1(KPrintF("%s/%s/%ld: mtre_iconnames=<%s>\n", \
3531 __FILE__, __FUNC__, __LINE__, MenuTree->MenuCombo.MenuTree.mtre_iconnames \
3532 ? MenuTree->MenuCombo.MenuTree.mtre_iconnames : (STRPTR) ""));
3533 }
3534 MenuTree->mtre_tree = (APTR) SCA_BE2LONG(MenuTree->mtre_tree);
3535 if (MenuTree->mtre_tree)
3536 {
3537 MenuTree->mtre_tree = (struct ScalosMenuTree *) (((UBYTE *) MenuTree->mtre_tree) + (ULONG) BaseAddr);
3538 AddAddresses(MenuTree->mtre_tree, BaseAddr);
3539 }
3540 MenuTree->mtre_Next = SCA_BE2LONG(MenuTree->mtre_Next);
3541 if (MenuTree->mtre_Next)
3542 {
3543 MenuTree->mtre_Next = (struct ScalosMenuTree *) (((UBYTE *) MenuTree->mtre_Next) + (ULONG) BaseAddr);
3544 }
3545 MenuTree = MenuTree->mtre_Next;
3546 }
3547 }
3548
3549
3550 static void GenerateMenuList(struct MenuPrefsInst *inst, struct ScalosMenuTree *mTree,
3551 Object *ListTree, struct MUI_NListtree_TreeNode *MenuNode)
3552 {
3553 while (mTree)
3554 {
3555 struct MenuInsertEntry mie;
3556 struct MUI_NListtree_TreeNode *TreeNode;
3557 ULONG MenuType = mTree->mtre_type;
3558 ULONG Flags = 0;
3559 ULONG pos;
3560
3561 mie.mie_TreeEntry = mTree;
3562 mie.mie_MenuFlags = 0;
3563
3564 d1(KPrintF("%s/%s/%ld: mTree=%08lx Type=%ld\n", __FILE__, __FUNC__, __LINE__, mTree, MenuType));
3565
3566 switch (MenuType)
3567 {
3568 case SCAMENUTYPE_Command:
3569 d1(kprintf("%s/%s/%ld: Command name <%s> ListNode=<%s>\n", \
3570 __FILE__, __FUNC__, __LINE__, mTree->MenuCombo.MenuCommand.mcom_name, MenuNode->tn_Name));
3571
3572 DoMethod(ListTree,
3573 MUIM_NListtree_Insert, "",
3574 &mie,
3575 MenuNode, MUIV_NListtree_Insert_PrevNode_Tail, 0);
3576 break;
3577
3578 default:
3579 d1(KPrintF("%s/%s/%ld: Menu name <%s> ListNode=<%s>\n", \
3580 __FILE__, __FUNC__, __LINE__, mTree->MenuCombo.MenuTree.mtre_name, MenuNode->tn_Name));
3581
3582 if (SCAMENUTYPE_ToolsMenu == mTree->mtre_type)
3583 mie.mie_MenuFlags |= LLISTFLGF_NotRemovable;
3584
3585 Flags |= TNF_LIST;
3586
3587 //.menu
3588 if (NULL == mTree->MenuCombo.MenuTree.mtre_name || 0 == strlen(mTree->MenuCombo.MenuTree.mtre_name))
3589 Flags |= TNF_NOSIGN;
3590
3591 if (SCAMENUTYPE_ToolsMenu != MenuType)
3592 {
3593 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(ListTree,
3594 MUIM_NListtree_Insert, mTree->MenuCombo.MenuTree.mtre_name ? mTree->MenuCombo.MenuTree.mtre_name : (STRPTR) "",
3595 &mie,
3596 MenuNode, MUIV_NListtree_Insert_PrevNode_Tail, Flags);
3597 }
3598 else
3599 {
3600 TreeNode = NULL;
3601
3602 for (pos=0; ; pos++)
3603 {
3604 struct MenuListEntry *mle;
3605
3606 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(ListTree,
3607 MUIM_NListtree_GetEntry, NULL, pos, 0);
3608
3609 if (NULL == TreeNode)
3610 break;
3611
3612 mle = (struct MenuListEntry *) TreeNode->tn_User;
3613
3614 if (SCAMENUTYPE_ToolsMenu == mle->llist_EntryType)
3615 break;
3616 }
3617
3618 if (NULL == TreeNode)
3619 {
3620 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(ListTree,
3621 MUIM_NListtree_Insert, mTree->MenuCombo.MenuTree.mtre_name ? mTree->MenuCombo.MenuTree.mtre_name : (STRPTR) "",
3622 &mie,
3623 MenuNode, MUIV_NListtree_Insert_PrevNode_Tail, Flags);
3624 }
3625 }
3626
3627 if (mTree->mtre_tree)
3628 GenerateMenuList(inst, mTree->mtre_tree, ListTree, TreeNode);
3629 break;
3630 }
3631
3632 mTree = mTree->mtre_Next;
3633 }
3634 }
3635
3636
3637 static SAVEDS(APTR) INTERRUPT ImportTDHookFunc(struct Hook *hook, Object *o, Msg msg)
3638 {
3639 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
3640 char FileName[1000];
3641 BPTR fd;
3642
3643 if (!RequestTdFile(inst, FileName, sizeof(FileName)))
3644 return NULL;
3645
3646 fd = Open(FileName, MODE_OLDFILE);
3647 if (fd)
3648 {
3649 char Line[512];
3650 struct MUI_NListtree_TreeNode *MenuNode = NULL;
3651 struct MUI_NListtree_TreeNode *ItemNode = NULL;
3652 struct MUI_NListtree_TreeNode *SubNode = NULL;
3653 struct MUI_NListtree_TreeNode *CmdNode = NULL;
3654 struct MenuInsertEntry mie;
3655 struct ScalosMenuTree mTree;
3656
3657 memset(&mTree, 0, sizeof(mTree));
3658 mie.mie_TreeEntry = &mTree;
3659 mie.mie_MenuFlags = 0;
3660
3661 ClearMenuList(inst);
3662
3663 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NListtree_Close,
3664 MUIV_NListtree_Close_ListNode_Root,
3665 MUIV_NListtree_Close_TreeNode_All,
3666 0);
3667
3668 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, TRUE);
3669 inst->mpb_QuietFlag = TRUE;
3670
3671 while (NULL != FGets(fd, Line, sizeof(Line) - 1))
3672 {
3673 STRPTR lp;
3674
3675 StripLF(Line);
3676 lp = stpblk(Line);
3677
3678 if (CmpWord("TITLE", lp))
3679 {
3680 lp = NextWord(lp);
3681
3682 CmdNode = SubNode = ItemNode = NULL;
3683 mTree.mtre_type = SCAMENUTYPE_Menu;
3684
3685 MenuNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
3686 MUIM_NListtree_Insert, lp,
3687 &mie,
3688 &inst->mpb_MainMenuNode,
3689 MenuNode ? MenuNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
3690 MUIV_NListtree_Insert_Flag_Active | TNF_OPEN | TNF_LIST);
3691
3692 continue;
3693 }
3694 if (CmpWord("ITEM", lp))
3695 {
3696 lp = NextWord(lp);
3697
3698 if (NULL == MenuNode)
3699 break;
3700
3701 CmdNode = SubNode = NULL;
3702 mTree.mtre_type = SCAMENUTYPE_MenuItem;
3703
3704 ItemNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
3705 MUIM_NListtree_Insert, lp,
3706 &mie,
3707 MenuNode,
3708 ItemNode ? ItemNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
3709 MUIV_NListtree_Insert_Flag_Active | TNF_OPEN | TNF_LIST);
3710
3711 continue;
3712 }
3713 if (CmpWord("ITEMBAR", lp))
3714 {
3715 if (NULL == MenuNode)
3716 break;
3717
3718 CmdNode = SubNode = NULL;
3719 mTree.mtre_type = SCAMENUTYPE_MenuItem;
3720
3721 ItemNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
3722 MUIM_NListtree_Insert, "",
3723 &mie,
3724 MenuNode,
3725 ItemNode ? ItemNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
3726 MUIV_NListtree_Insert_Flag_Active | TNF_OPEN | TNF_LIST | TNF_NOSIGN);
3727
3728 continue;
3729 }
3730 if (CmpWord("(CLI)", lp))
3731 {
3732 struct MUI_NListtree_TreeNode *ParentNode;
3733 struct MenuListEntry *mle;
3734 ULONG StackSize;
3735
3736 if (SubNode)
3737 ParentNode = SubNode;
3738 else
3739 ParentNode = ItemNode;
3740
3741 if (NULL == ParentNode)
3742 break;
3743
3744 lp = NextWord(lp);
3745
3746 StackSize = atoi(lp);
3747
3748 lp = NextWord(lp);
3749
3750 mTree.mtre_type = SCAMENUTYPE_Command;
3751
3752 CmdNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
3753 MUIM_NListtree_Insert, lp,
3754 &mie,
3755 ParentNode,
3756 CmdNode ? CmdNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
3757 MUIV_NListtree_Insert_Flag_Active);
3758
3759 mle = (struct MenuListEntry *) CmdNode->tn_User;
3760
3761 mle->llist_Stack = StackSize;
3762 mle->llist_CommandType = SCAMENUCMDTYPE_AmigaDOS;
3763
3764 continue;
3765 }
3766 if (CmpWord("(WB)", lp))
3767 {
3768 struct MUI_NListtree_TreeNode *ParentNode;
3769 struct MenuListEntry *mle;
3770
3771 if (SubNode)
3772 ParentNode = SubNode;
3773 else
3774 ParentNode = ItemNode;
3775
3776 if (NULL == ParentNode)
3777 break;
3778
3779 lp = NextWord(lp);
3780
3781 mTree.mtre_type = SCAMENUTYPE_Command;
3782
3783 CmdNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
3784 MUIM_NListtree_Insert, lp,
3785 &mie,
3786 ParentNode,
3787 CmdNode ? CmdNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
3788 MUIV_NListtree_Insert_Flag_Active);
3789
3790 mle = (struct MenuListEntry *) CmdNode->tn_User;
3791
3792 mle->llist_CommandType = SCAMENUCMDTYPE_Workbench;
3793 mle->llist_Stack = DEFAULT_STACKSIZE;
3794
3795 continue;
3796 }
3797 if (CmpWord("HOTKEY", lp))
3798 {
3799 struct MUI_NListtree_TreeNode *ParentNode;
3800 struct MenuListEntry *mle;
3801
3802 if (SubNode)
3803 ParentNode = SubNode;
3804 else
3805 ParentNode = ItemNode;
3806
3807 if (NULL == ParentNode)
3808 break;
3809
3810 lp = NextWord(lp);
3811
3812 mle = (struct MenuListEntry *) ParentNode->tn_User;
3813
3814 stccpy(mle->llist_HotKey, lp, sizeof(mle->llist_HotKey));
3815
3816 continue;
3817 }
3818 if (CmpWord("SUB", lp))
3819 {
3820 lp = NextWord(lp);
3821
3822 if (NULL == ItemNode)
3823 break;
3824
3825 CmdNode = NULL;
3826 mTree.mtre_type = SCAMENUTYPE_Menu;
3827
3828 SubNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
3829 MUIM_NListtree_Insert, lp,
3830 &mie,
3831 ItemNode,
3832 SubNode ? SubNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
3833 MUIV_NListtree_Insert_Flag_Active | TNF_OPEN | TNF_LIST);
3834
3835 continue;
3836 }
3837 }
3838
3839 Close(fd);
3840
3841 inst->mpb_QuietFlag = FALSE;
3842 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, FALSE);
3843
3844 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NListtree_Open,
3845 MUIV_NListtree_Open_ListNode_Root,
3846 MUIV_NListtree_Open_TreeNode_All,
3847 0);
3848 }
3849
3850 SetChangedFlag(inst, TRUE);
3851
3852 return NULL;
3853 }
3854
3855
3856 static BOOL RequestTdFile(struct MenuPrefsInst *inst, char *FileName, size_t MaxLen)
3857 {
3858 struct FileRequester *Req = MUI_AllocAslRequest(ASL_FileRequest, NULL);
3859 BOOL Result = FALSE;
3860
3861 if (Req)
3862 {
3863 struct Window *win = NULL;
3864
3865 get(inst->mpb_Objects[OBJNDX_WIN_Main], MUIA_Window_Window, &win);
3866
3867 // MUI_AslRequest()
3868 Result = MUI_AslRequestTags(Req,
3869 ASLFR_TitleText, GetLocString(MSGID_TITLE_IMPORTTD),
3870 ASLFR_InitialFile, "ToolsDaemon.menu",
3871 ASLFR_InitialDrawer, "S:",
3872 ASLFR_Window, win,
3873 ASLFR_SleepWindow, TRUE,
3874 ASLFR_Flags1, FRF_DOPATTERNS,
3875 TAG_END);
3876
3877 if (Result)
3878 {
3879 stccpy(FileName, Req->fr_Drawer, MaxLen);
3880 AddPart(FileName, Req->fr_File, MaxLen);
3881 }
3882 }
3883
3884 return Result;
3885 }
3886
3887
3888 static BOOL RequestParmFile(struct MenuPrefsInst *inst, char *FileName, size_t MaxLen)
3889 {
3890 struct FileRequester *Req = MUI_AllocAslRequest(ASL_FileRequest, NULL);
3891 BOOL Result = FALSE;
3892
3893 if (Req)
3894 {
3895 struct Window *win = NULL;
3896
3897 get(inst->mpb_Objects[OBJNDX_WIN_Main], MUIA_Window_Window, &win);
3898
3899 // MUI_AslRequest()
3900 Result = MUI_AslRequestTags(Req,
3901 ASLFR_TitleText, GetLocString(MSGID_TITLE_IMPORTP),
3902 ASLFR_InitialFile, "ParM.cfg",
3903 ASLFR_InitialDrawer, "",
3904 ASLFR_Window, win,
3905 ASLFR_SleepWindow, TRUE,
3906 ASLFR_Flags1, FRF_DOPATTERNS,
3907 TAG_END);
3908
3909 if (Result)
3910 {
3911 stccpy(FileName, Req->fr_Drawer, MaxLen);
3912 AddPart(FileName, Req->fr_File, MaxLen);
3913 }
3914 }
3915
3916 return Result;
3917 }
3918
3919
3920 static BOOL CmpWord(CONST_STRPTR Cmd, CONST_STRPTR Line)
3921 {
3922 while (*Line && (tolower(*Cmd) == tolower(*Line)))
3923 {
3924 Cmd++;
3925 Line++;
3926 }
3927
3928 return (BOOL) ('\0' == *Cmd && ('\0' == *Line || isspace(*Line)));
3929 }
3930
3931
3932 static void StripLF(STRPTR Line)
3933 {
3934 size_t Len = strlen(Line);
3935
3936 Line += Len - 1;
3937
3938 if ('\n' == *Line)
3939 *Line = '\0';
3940 }
3941
3942
3943 static STRPTR NextWord(STRPTR lp)
3944 {
3945 if ('"' == *lp)
3946 {
3947 lp++; // skip leading '"'
3948 while (*lp && '"' != *lp)
3949 lp++;
3950 if ('"' == *lp)
3951 lp++; // skip trailing '"'
3952 }
3953 else
3954 {
3955 while (*lp && !isspace(*lp))
3956 lp++;
3957 }
3958
3959 return stpblk(lp);
3960 }
3961
3962
3963 static void CopyWord(STRPTR dest, CONST_STRPTR src, size_t MaxLen)
3964 {
3965 if ('"' == *src)
3966 {
3967 src++; // skip leading '"'
3968 while (*src && '"' != *src && MaxLen > 1)
3969 {
3970 *dest++ = *src++;
3971 MaxLen--;
3972 }
3973 }
3974 else
3975 {
3976 while (*src && !isspace(*src) && MaxLen > 1)
3977 {
3978 *dest++ = *src++;
3979 MaxLen--;
3980 }
3981 }
3982
3983 *dest = '\0';
3984 }
3985
3986
3987 static SAVEDS(APTR) INTERRUPT ImportPHookFunc(struct Hook *hook, Object *o, Msg msg)
3988 {
3989 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
3990 char FileName[1000];
3991 BPTR fd;
3992
3993 if (!RequestParmFile(inst, FileName, sizeof(FileName)))
3994 return NULL;
3995
3996 fd = Open(FileName, MODE_OLDFILE);
3997 // fd = Open("ParM.cfg", MODE_OLDFILE);
3998 if (fd)
3999 {
4000 struct MUI_NListtree_TreeNode *MenuNode = NULL;
4001 struct MUI_NListtree_TreeNode *ItemNode = NULL;
4002 struct MUI_NListtree_TreeNode *SubNode = NULL;
4003 struct MUI_NListtree_TreeNode *CmdNode;
4004 char Line[512];
4005 struct MenuInsertEntry mie;
4006 struct ScalosMenuTree mTree;
4007
4008 memset(&mTree, 0, sizeof(mTree));
4009 mie.mie_TreeEntry = &mTree;
4010 mie.mie_MenuFlags = 0;
4011
4012 ClearMenuList(inst);
4013
4014 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NListtree_Close,
4015 MUIV_NListtree_Close_ListNode_Root,
4016 MUIV_NListtree_Close_TreeNode_All,
4017 0);
4018
4019 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, TRUE);
4020 inst->mpb_QuietFlag = TRUE;
4021
4022 while (NULL != FGets(fd, Line, sizeof(Line) - 1))
4023 {
4024 char ItemName[100];
4025 STRPTR lp;
4026
4027 StripLF(Line);
4028 lp = stpblk(Line);
4029
4030 if ('#' == *lp || 0 == strlen(lp))
4031 continue;
4032
4033 if (CmpWord("MENU", lp))
4034 {
4035 lp = NextWord(lp);
4036
4037 CopyWord(ItemName, lp, sizeof(ItemName));
4038
4039 d1(kprintf("%s/%s/%ld: ITEM <%s> Menu=%08lx Item=%08lx Sub=%08lx\n", \
4040 __FILE__, __FUNC__, __LINE__, ItemName, MenuNode, ItemNode, SubNode));
4041
4042 SubNode = ItemNode = NULL;
4043 mTree.mtre_type = SCAMENUTYPE_Menu;
4044
4045 MenuNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4046 MUIM_NListtree_Insert, ItemName,
4047 &mie,
4048 &inst->mpb_MainMenuNode,
4049 MenuNode ? MenuNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Head,
4050 TNF_OPEN | TNF_LIST);
4051
4052 continue;
4053 }
4054 if (CmpWord("ITEM", lp))
4055 {
4056 struct MenuListEntry *mle;
4057 char HotKey[2];
4058
4059 lp = NextWord(lp);
4060
4061 if (NULL == MenuNode)
4062 break;
4063
4064 CmdNode = NULL;
4065 strcpy(HotKey, "");
4066
4067 if ('{' == *lp)
4068 {
4069 HotKey[0] = lp[1];
4070 lp = NextWord(lp);
4071 }
4072
4073 CopyWord(ItemName, lp, sizeof(ItemName));
4074
4075 d1(kprintf("%s/%s/%ld: ITEM <%s> Menu=%08lx Item=%08lx Sub=%08lx\n", \
4076 __FILE__, __FUNC__, __LINE__, ItemName, MenuNode, ItemNode, SubNode));
4077
4078 mTree.mtre_type = SCAMENUTYPE_MenuItem;
4079
4080 ItemNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4081 MUIM_NListtree_Insert, ItemName,
4082 &mie,
4083 SubNode ? SubNode : MenuNode,
4084 ItemNode ? ItemNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
4085 TNF_OPEN | TNF_LIST);
4086
4087 mle = (struct MenuListEntry *) ItemNode->tn_User;
4088
4089 stccpy(mle->llist_HotKey, HotKey, sizeof(mle->llist_HotKey));
4090
4091 lp = NextWord(stpblk(lp));
4092
4093 if (CmpWord("WB", lp))
4094 {
4095 lp = NextWord(lp);
4096 mTree.mtre_type = SCAMENUTYPE_Command;
4097
4098 CmdNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4099 MUIM_NListtree_Insert, lp,
4100 &mie,
4101 ItemNode,
4102 CmdNode ? CmdNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
4103 0);
4104
4105 mle = (struct MenuListEntry *) CmdNode->tn_User;
4106
4107 mle->llist_CommandType = SCAMENUCMDTYPE_Workbench;
4108 mle->llist_Stack = DEFAULT_STACKSIZE;
4109 }
4110 else if (CmpWord("RUN", lp) || CmpWord("SHELL", lp))
4111 {
4112 lp = NextWord(lp);
4113 mTree.mtre_type = SCAMENUTYPE_Command;
4114
4115 CmdNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4116 MUIM_NListtree_Insert, lp,
4117 &mie,
4118 ItemNode,
4119 CmdNode ? CmdNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
4120 0);
4121
4122 mle = (struct MenuListEntry *) CmdNode->tn_User;
4123
4124 mle->llist_Stack = DEFAULT_STACKSIZE;
4125 mle->llist_CommandType = SCAMENUCMDTYPE_AmigaDOS;
4126 }
4127
4128 continue;
4129 }
4130 if (CmpWord("BARLABEL", lp))
4131 {
4132 if (NULL == MenuNode)
4133 break;
4134
4135 SubNode = NULL;
4136 mTree.mtre_type = SCAMENUTYPE_MenuItem;
4137
4138 ItemNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4139 MUIM_NListtree_Insert, "",
4140 &mie,
4141 MenuNode,
4142 ItemNode ? ItemNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
4143 TNF_LIST | TNF_NOSIGN);
4144
4145 continue;
4146 }
4147 if (CmpWord("SUBMENU", lp))
4148 {
4149 lp = NextWord(lp);
4150
4151 if (SubNode)
4152 break;
4153
4154 CopyWord(ItemName, lp, sizeof(ItemName));
4155
4156 d1(kprintf("%s/%s/%ld: SUBMENU <%s> Menu=%08lx Item=%08lx Sub=%08lx\n", \
4157 __FILE__, __FUNC__, __LINE__, ItemName, MenuNode, ItemNode, SubNode));
4158
4159 mTree.mtre_type = SCAMENUTYPE_Menu;
4160
4161 SubNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4162 MUIM_NListtree_Insert, ItemName,
4163 &mie,
4164 MenuNode,
4165 ItemNode ? ItemNode : (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
4166 TNF_OPEN | TNF_LIST);
4167
4168 continue;
4169 }
4170 if (CmpWord("ENDSUBMENU", lp))
4171 {
4172 d1(kprintf("%s/%s/%ld: ENDSUBMENU Menu=%08lx Item=%08lx Sub=%08lx\n", \
4173 __FILE__, __FUNC__, __LINE__, MenuNode, ItemNode, SubNode));
4174
4175 if (NULL == SubNode)
4176 break;
4177
4178 ItemNode = SubNode;
4179 SubNode = NULL;
4180
4181 continue;
4182 }
4183 }
4184
4185 Close(fd);
4186
4187 inst->mpb_QuietFlag = FALSE;
4188
4189 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, FALSE);
4190
4191 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NListtree_Open,
4192 MUIV_NListtree_Open_ListNode_Root,
4193 MUIV_NListtree_Open_TreeNode_All,
4194 0);
4195 }
4196
4197 SetChangedFlag(inst, TRUE);
4198
4199 return NULL;
4200 }
4201
4202
4203 //----------------------------------------------------------------------------
4204
4205 static SAVEDS(APTR) INTERRUPT CollapseSelectedHookFunc(struct Hook *hook, Object *o, Msg msg)
4206 {
4207 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4208 struct MUI_NListtree_TreeNode *tn;
4209
4210 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NList_Quiet, MUIV_NList_Quiet_Full);
4211
4212 tn = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4213 MUIM_NListtree_GetEntry,
4214 MUIV_NListtree_GetEntry_ListNode_Active,
4215 MUIV_NListtree_GetEntry_Position_Active,
4216 0);
4217 d1(kprintf("%s/%ld: active tn=%08lx <%s>\n", __FUNC__, __LINE__, tn, tn ? tn->tn_Name : (STRPTR) ""));
4218
4219 if (tn)
4220 {
4221 struct MUI_NListtree_TreeNode *tnChild;
4222
4223 tnChild = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4224 MUIM_NListtree_GetEntry,
4225 tn,
4226 MUIV_NListtree_GetEntry_Position_Head,
4227 0);
4228 d1(kprintf("%s/%ld: Head tn=%08lx <%s>\n", __FUNC__, __LINE__, tnChild, tnChild ? tnChild->tn_Name : (STRPTR) ""));
4229
4230 if (tnChild)
4231 {
4232 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Active, (ULONG) tnChild);
4233
4234 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4235 MUIM_NListtree_Close,
4236 MUIV_NListtree_Close_ListNode_Active,
4237 MUIV_NListtree_Close_TreeNode_All,
4238 0);
4239 }
4240
4241 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Active, (ULONG) tn);
4242 }
4243
4244 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4245 MUIM_NListtree_Close,
4246 MUIV_NListtree_Close_ListNode_Active,
4247 tn,
4248 0);
4249
4250 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NList_Quiet, MUIV_NList_Quiet_None);
4251
4252 return NULL;
4253 }
4254
4255 //----------------------------------------------------------------------------
4256
4257 static SAVEDS(APTR) INTERRUPT ExpandSelectedHookFunc(struct Hook *hook, Object *o, Msg msg)
4258 {
4259 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4260 struct MUI_NListtree_TreeNode *tn;
4261
4262 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NList_Quiet, MUIV_NList_Quiet_Full);
4263
4264 tn = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4265 MUIM_NListtree_GetEntry,
4266 MUIV_NListtree_GetEntry_ListNode_Active,
4267 MUIV_NListtree_GetEntry_Position_Active,
4268 0);
4269 d1(kprintf("%s/%ld: active tn=%08lx <%s>\n", __FUNC__, __LINE__, tn, tn ? tn->tn_Name : (STRPTR) ""));
4270
4271 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4272 MUIM_NListtree_Open,
4273 MUIV_NListtree_Open_ListNode_Active,
4274 MUIV_NListtree_Open_TreeNode_Active,
4275 0);
4276
4277 if (tn)
4278 {
4279 struct MUI_NListtree_TreeNode *tnChild;
4280
4281 tnChild = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4282 MUIM_NListtree_GetEntry,
4283 tn,
4284 MUIV_NListtree_GetEntry_Position_Head,
4285 0);
4286 d1(kprintf("%s/%ld: Head tn=%08lx <%s>\n", __FUNC__, __LINE__, tnChild, tnChild ? tnChild->tn_Name : (STRPTR) ""));
4287
4288 if (tnChild)
4289 {
4290 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Active, (ULONG) tnChild);
4291
4292 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4293 MUIM_NListtree_Open,
4294 MUIV_NListtree_Open_ListNode_Active,
4295 MUIV_NListtree_Open_TreeNode_All,
4296 0);
4297 }
4298
4299 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Active, (ULONG) tn);
4300 }
4301
4302 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NList_Quiet, MUIV_NList_Quiet_None);
4303
4304 return NULL;
4305 }
4306
4307 //----------------------------------------------------------------------------
4308
4309 static SAVEDS(APTR) INTERRUPT CollapseAllHookFunc(struct Hook *hook, Object *o, Msg msg)
4310 {
4311 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4312
4313 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NListtree_Close,
4314 MUIV_NListtree_Close_ListNode_Root, MUIV_NListtree_Close_TreeNode_All, 0);
4315
4316 return 0;
4317 }
4318
4319 //----------------------------------------------------------------------------
4320
4321 static SAVEDS(APTR) INTERRUPT ExpandAllHookFunc(struct Hook *hook, Object *o, Msg msg)
4322 {
4323 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4324
4325 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NListtree_Open,
4326 MUIV_NListtree_Open_ListNode_Root, MUIV_NListtree_Open_TreeNode_All, 0);
4327
4328 return 0;
4329 }
4330
4331 //----------------------------------------------------------------------------
4332
4333 static SAVEDS(APTR) INTERRUPT CmdSelectedHookFunc(struct Hook *hook, Object *o, Msg msg)
4334 {
4335 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4336 struct CommandTableEntry *cte = NULL;
4337
4338 DoMethod(inst->mpb_Objects[OBJNDX_CmdListView], MUIM_List_GetEntry, MUIV_List_GetEntry_Active, &cte);
4339 if (cte)
4340 {
4341 set(inst->mpb_Objects[OBJNDX_StringCmd], MUIA_String_Contents, (ULONG) cte->cte_Command);
4342
4343 DoMethod(inst->mpb_Objects[OBJNDX_PopObject], MUIM_Popstring_Close, 0);
4344
4345 ChangeEntry3HookFunc(hook, o, msg);
4346 }
4347
4348 return 0;
4349 }
4350
4351 //----------------------------------------------------------------------------
4352
4353 static SAVEDS(APTR) INTERRUPT ContextMenuTriggerHookFunc(struct Hook *hook, Object *o, Msg msg)
4354 {
4355 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4356 Object *MenuObj = *((Object **) msg);
4357 ULONG MenuHookIndex = 0;
4358 struct Hook *MenuHook = NULL;
4359
4360 d1(kprintf("%s/%s//%ld: MenuObj=%08lx\n", __FILE__, __FUNC__, __LINE__, MenuObj));
4361 d1(kprintf("%s/%s//%ld: msg=%08lx *msg=%08lx\n", __FILE__, __FUNC__, __LINE__, msg, *((ULONG *) msg)));
4362
4363 get(MenuObj, MUIA_UserData, &MenuHookIndex);
4364
4365 if (MenuHookIndex > 0 && MenuHookIndex < HOOKNDX_MAX)
4366 MenuHook = &inst->mpb_Hooks[MenuHookIndex];
4367
4368 d1(kprintf("%s/%s//%ld: MenuHook=%08lx\n", __FILE__, __FUNC__, __LINE__, MenuHook));
4369 if (MenuHook)
4370 DoMethod(inst->mpb_Objects[OBJNDX_Group_Main], MUIM_CallHook, MenuHook, 0);
4371
4372 return NULL;
4373 }
4374
4375
4376 static SAVEDS(APTR) INTERRUPT AppMessageHookFunc(struct Hook *hook, Object *o, Msg msg)
4377 {
4378 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4379 struct AppMessage *AppMsg = *(struct AppMessage **) msg;
4380 struct MUI_NListtree_TreeNode *TreeNode = NULL;
4381
4382 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, TRUE);
4383
4384 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4385 MUIM_NListtree_GetEntry, MUIV_NListtree_GetEntry_ListNode_Active,
4386 MUIV_NListtree_GetEntry_Position_Active, 0);
4387
4388 if (TreeNode)
4389 {
4390 struct MUI_NListtree_TreeNode *ParentNode = (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail;
4391 LONG n;
4392
4393 for (n=0; n<AppMsg->am_NumArgs; )
4394 {
4395 struct MenuListEntry *mle = (struct MenuListEntry *) TreeNode->tn_User;
4396 char Buffer[1000];
4397 STRPTR FileName;
4398
4399 if (!NameFromLock(AppMsg->am_ArgList[n].wa_Lock, Buffer, sizeof(Buffer)))
4400 break;
4401 if (AppMsg->am_ArgList[n].wa_Name && strlen(AppMsg->am_ArgList[n].wa_Name) > 0)
4402 AddPart(Buffer, AppMsg->am_ArgList[n].wa_Name, sizeof(Buffer));
4403
4404 FileName = FilePart(Buffer);
4405
4406 switch (mle->llist_EntryType)
4407 {
4408 case SCAMENUTYPE_MainMenu:
4409 d1(kprintf("%s/%s/%ld: insert at SCAMENUTYPE_MainMenu\n", __FILE__, __FUNC__, __LINE__));
4410 if (mle->llist_Flags & LLISTFLGF_MayNotHaveChildren)
4411 {
4412 AppMessage_Menu(inst, &TreeNode, &ParentNode, &AppMsg->am_ArgList[n], Buffer, FileName);
4413 n++;
4414 }
4415 else
4416 {
4417 struct MenuInsertEntry mie;
4418 struct ScalosMenuTree mTree;
4419
4420 memset(&mTree, 0, sizeof(mTree));
4421 mie.mie_TreeEntry = &mTree;
4422 mie.mie_MenuFlags = 0;
4423 mTree.mtre_type = SCAMENUTYPE_Menu;
4424
4425 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4426 MUIM_NListtree_Insert, "DragIn Menu",
4427 &mie,
4428 TreeNode, ParentNode, TNF_OPEN | TNF_LIST);
4429 }
4430 break;
4431
4432 case SCAMENUTYPE_Menu:
4433 case SCAMENUTYPE_ToolsMenu:
4434 d1(kprintf("%s/%s/%ld: insert at SCAMENUTYPE_Menu\n", __FILE__, __FUNC__, __LINE__));
4435 AppMessage_Menu(inst, &TreeNode, &ParentNode, &AppMsg->am_ArgList[n], Buffer, FileName);
4436 n++;
4437 break;
4438
4439 case SCAMENUTYPE_MenuItem:
4440 d1(kprintf("%s/%s/%ld: insert at SCAMENUTYPE_MenuItem\n", __FILE__, __FUNC__, __LINE__));
4441 ParentNode = TreeNode;
4442 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4443 MUIM_NListtree_GetEntry, TreeNode, MUIV_NListtree_GetEntry_Position_Parent, 0);
4444
4445 AppMessage_Menu(inst, &TreeNode, &ParentNode, &AppMsg->am_ArgList[n], Buffer, FileName);
4446 n++;
4447 break;
4448
4449 case SCAMENUTYPE_Command:
4450 d1(kprintf("%s/%s/%ld: insert at SCAMENUTYPE_Command\n", __FILE__, __FUNC__, __LINE__));
4451 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4452 MUIM_NListtree_GetEntry, TreeNode, MUIV_NListtree_GetEntry_Position_Parent, 0);
4453 break;
4454
4455 default:
4456 break;
4457 }
4458 }
4459 }
4460
4461 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NListtree_Quiet, FALSE);
4462
4463 return 0;
4464 }
4465
4466
4467 static struct MUI_NListtree_TreeNode *AppMessage_Menu(struct MenuPrefsInst *inst,
4468 struct MUI_NListtree_TreeNode **TreeNode,
4469 struct MUI_NListtree_TreeNode **ParentNode, const struct WBArg *wbArg,
4470 CONST_STRPTR Path, CONST_STRPTR FileName)
4471 {
4472 struct MUI_NListtree_TreeNode *NewTreeNode;
4473 struct MenuListEntry *mle;
4474 struct MenuInsertEntry mie;
4475 struct ScalosMenuTree mTree;
4476
4477 memset(&mTree, 0, sizeof(mTree));
4478 mie.mie_TreeEntry = &mTree;
4479 mie.mie_MenuFlags = 0;
4480
4481 d1(kprintf("%s/%s/%ld: listnode=%08lx <%s> prevtreenode=%08lx\n", \
4482 __FILE__, __FUNC__, __LINE__, *TreeNode, (*TreeNode)->tn_Name, *ParentNode));
4483
4484 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
4485 SetChangedFlag(inst, TRUE);
4486
4487 mTree.mtre_type = SCAMENUTYPE_MenuItem;
4488
4489 *TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4490 MUIM_NListtree_Insert, FileName,
4491 &mie,
4492 *TreeNode, *ParentNode, TNF_OPEN | TNF_LIST);
4493
4494 d1(kprintf("%s/%s/%ld: listnode=%08lx <%s> prevtreenode=%08lx\n", \
4495 __FILE__, __FUNC__, __LINE__, *TreeNode, (*TreeNode)->tn_Name, *ParentNode));
4496
4497 mTree.mtre_type = SCAMENUTYPE_Command;
4498
4499 NewTreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4500 MUIM_NListtree_Insert, "",
4501 &mie,
4502 *TreeNode, MUIV_NListtree_Insert_PrevNode_Tail, 0);
4503 if (NULL == NewTreeNode)
4504 return NULL;
4505
4506 mle = (struct MenuListEntry *) NewTreeNode->tn_User;
4507
4508 stccpy(mle->llist_name, Path, sizeof(mle->llist_name));
4509
4510 mle->llist_Stack = DEFAULT_STACKSIZE;
4511 mle->llist_Priority = 0;
4512
4513 if (FileName && strlen(FileName) > 0)
4514 mle->llist_CommandType = SCAMENUCMDTYPE_Workbench;
4515 else
4516 mle->llist_CommandType = SCAMENUCMDTYPE_IconWindow;
4517
4518 return NewTreeNode;
4519 }
4520
4521 //----------------------------------------------------------------------------
4522
4523 static SAVEDS(APTR) INTERRUPT SettingsChangedHookFunc(struct Hook *hook, Object *o, Msg msg)
4524 {
4525 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4526
4527 d1(kprintf("%s/%s/%ld: \n", __FILE__, __FUNC__, __LINE__));
4528 SetChangedFlag(inst, TRUE);
4529
4530 return NULL;
4531 }
4532
4533 //----------------------------------------------------------------------------
4534
4535 static SAVEDS(void) INTERRUPT AslIntuiMsgHookFunc(struct Hook *hook, Object *o, Msg msg)
4536 {
4537 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4538 struct IntuiMessage *iMsg = (struct IntuiMessage *) msg;
4539
4540 if (IDCMP_REFRESHWINDOW == iMsg->Class)
4541 {
4542 DoMethod(inst->mpb_Objects[OBJNDX_APP_Main], MUIM_Application_CheckRefresh);
4543 }
4544 }
4545
4546 //----------------------------------------------------------------------------
4547
4548 static SAVEDS(void) INTERRUPT HideObsoleteHookFunc(struct Hook *hook, Object *o, Msg msg)
4549 {
4550 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4551 ULONG HideObsolete = 0;
4552
4553 //TODO
4554 get(inst->mpb_Objects[OBJNDX_Menu_HideObsolete], MUIA_Menuitem_Checked, &HideObsolete);
4555 inst->mpb_HideObsoletePopupMenus = HideObsolete;
4556
4557 d1(KPrintF("%s/%s/%ld: mpb_HideObsoletePopupMenus=%ld\n", __FILE__, __FUNC__, __LINE__, inst->mpb_HideObsoletePopupMenus));
4558
4559 set(inst->mpb_Objects[OBJNDX_MainListView], MUIA_NListtree_Quiet, TRUE);
4560 set(inst->mpb_Objects[OBJNDX_HiddenListTree], MUIA_NListtree_Quiet, TRUE);
4561
4562 if (inst->mpb_HideObsoletePopupMenus)
4563 {
4564 // Move obsolete entries from OBJNDX_MainListTree to OBJNDX_HiddenListTree
4565 MoveMenuTree(inst, OBJNDX_HiddenListTree, OBJNDX_MainListTree, POPMENUINDEX_Disk);
4566 MoveMenuTree(inst, OBJNDX_HiddenListTree, OBJNDX_MainListTree, POPMENUINDEX_Drawer);
4567 MoveMenuTree(inst, OBJNDX_HiddenListTree, OBJNDX_MainListTree, POPMENUINDEX_ToolProject);
4568 MoveMenuTree(inst, OBJNDX_HiddenListTree, OBJNDX_MainListTree, POPMENUINDEX_Trashcan);
4569 MoveMenuTree(inst, OBJNDX_HiddenListTree, OBJNDX_MainListTree, POPMENUINDEX_AppIcon);
4570 }
4571 else
4572 {
4573 // Move obsolete entries from OBJNDX_HiddenListTree to OBJNDX_MainListTree
4574 MoveMenuTree(inst, OBJNDX_MainListTree, OBJNDX_HiddenListTree, POPMENUINDEX_Disk);
4575 MoveMenuTree(inst, OBJNDX_MainListTree, OBJNDX_HiddenListTree, POPMENUINDEX_Drawer);
4576 MoveMenuTree(inst, OBJNDX_MainListTree, OBJNDX_HiddenListTree, POPMENUINDEX_ToolProject);
4577 MoveMenuTree(inst, OBJNDX_MainListTree, OBJNDX_HiddenListTree, POPMENUINDEX_Trashcan);
4578 MoveMenuTree(inst, OBJNDX_MainListTree, OBJNDX_HiddenListTree, POPMENUINDEX_AppIcon);
4579 }
4580
4581 set(inst->mpb_Objects[OBJNDX_MainListView], MUIA_NListtree_Quiet, FALSE);
4582 set(inst->mpb_Objects[OBJNDX_HiddenListTree], MUIA_NListtree_Quiet, FALSE);
4583
4584 d1(KPrintF("%s/%s/%ld: END\n", __FILE__, __FUNC__, __LINE__));
4585 }
4586
4587 //----------------------------------------------------------------------------
4588
4589 static SAVEDS(void) INTERRUPT MenuCopyHookFunc(struct Hook *hook, Object *o, Msg msg)
4590 {
4591 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4592 struct MUI_NListtree_TreeNode *TreeNode;
4593
4594 d1(KPrintF("%s/%s/%ld: START\n", __FILE__, __FUNC__, __LINE__));
4595
4596 if (inst->mpb_QuietFlag)
4597 return;
4598
4599 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4600 MUIM_NListtree_GetEntry,
4601 MUIV_NListtree_GetEntry_ListNode_Active,
4602 MUIV_NListtree_GetEntry_Position_Active, 0);
4603
4604 if (TreeNode)
4605 {
4606 DoMethod(inst->mpb_Objects[OBJNDX_ListTreeClipboard], MUIM_NListtree_Clear);
4607
4608 CopyFileTypesEntry(inst,
4609 (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_ListNode_Root,
4610 (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
4611 TreeNode,
4612 OBJNDX_ListTreeClipboard,
4613 OBJNDX_MainListTree);
4614 }
4615
4616 d1(KPrintF("%s/%s/%ld: END\n", __FILE__, __FUNC__, __LINE__));
4617 }
4618
4619 //----------------------------------------------------------------------------
4620
4621 static SAVEDS(void) INTERRUPT MenuCutHookFunc(struct Hook *hook, Object *o, Msg msg)
4622 {
4623 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4624 struct MUI_NListtree_TreeNode *TreeNode;
4625
4626 d1(KPrintF("%s/%s/%ld: START\n", __FILE__, __FUNC__, __LINE__));
4627
4628 if (inst->mpb_QuietFlag)
4629 return;
4630
4631 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4632 MUIM_NListtree_GetEntry,
4633 MUIV_NListtree_GetEntry_ListNode_Active,
4634 MUIV_NListtree_GetEntry_Position_Active, 0);
4635
4636 if (TreeNode)
4637 {
4638 DoMethod(inst->mpb_Objects[OBJNDX_ListTreeClipboard], MUIM_NListtree_Clear);
4639
4640 CopyFileTypesEntry(inst,
4641 (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_ListNode_Root,
4642 (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
4643 TreeNode,
4644 OBJNDX_ListTreeClipboard,
4645 OBJNDX_MainListTree);
4646
4647 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree], MUIM_NListtree_Remove,
4648 MUIV_NListtree_Remove_ListNode_Active,
4649 MUIV_NListtree_Remove_TreeNode_Active, 0);
4650 }
4651
4652 d1(KPrintF("%s/%s/%ld: END\n", __FILE__, __FUNC__, __LINE__));
4653 }
4654
4655 //----------------------------------------------------------------------------
4656
4657 static SAVEDS(void) INTERRUPT MenuPasteHookFunc(struct Hook *hook, Object *o, Msg msg)
4658 {
4659 struct MenuPrefsInst *inst = (struct MenuPrefsInst *) hook->h_Data;
4660 struct MUI_NListtree_TreeNode *tn;
4661
4662 d1(KPrintF("%s/%s/%ld: START\n", __FILE__, __FUNC__, __LINE__));
4663
4664 tn = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4665 MUIM_NListtree_GetEntry,
4666 MUIV_NListtree_GetEntry_ListNode_Active,
4667 MUIV_NListtree_GetEntry_Position_Active,
4668 0);
4669 d1(kprintf("%s/%ld: active tn=%08lx <%s>\n", __FUNC__, __LINE__, tn, tn ? tn->tn_Name : (STRPTR) ""));
4670
4671 if (tn)
4672 {
4673 struct MUI_NListtree_TreeNode *tnParent;
4674 struct MUI_NListtree_TreeNode *tnShadow;
4675
4676 tnParent = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4677 MUIM_NListtree_GetEntry,
4678 tn,
4679 MUIV_NListtree_GetEntry_Position_Parent,
4680 0);
4681
4682 tnShadow = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_ListTreeClipboard],
4683 MUIM_NListtree_GetEntry,
4684 MUIV_NListtree_Insert_ListNode_Root,
4685 MUIV_NListtree_GetEntry_Position_Head,
4686 0);
4687
4688 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NList_Quiet, MUIV_NList_Quiet_Full);
4689
4690 if (MayPasteBelow(inst, tn, tnShadow))
4691 {
4692 CopyFileTypesEntry(inst,
4693 tnParent, tn,
4694 tnShadow,
4695 OBJNDX_MainListTree, OBJNDX_ListTreeClipboard);
4696
4697 // EntryHasChanged(inst, tnParent);
4698 }
4699 else if (MayPasteOnto(inst, tn, tnShadow))
4700 {
4701 CopyFileTypesEntry(inst,
4702 tn, (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
4703 tnShadow,
4704 OBJNDX_MainListTree, OBJNDX_ListTreeClipboard);
4705
4706 // EntryHasChanged(inst, tn);
4707 }
4708
4709 set(inst->mpb_Objects[OBJNDX_MainListTree], MUIA_NList_Quiet, MUIV_NList_Quiet_None);
4710
4711 DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4712 MUIM_NListtree_Redraw,
4713 tn,
4714 0);
4715 }
4716
4717 d1(KPrintF("%s/%s/%ld: END\n", __FILE__, __FUNC__, __LINE__));
4718 }
4719
4720 //----------------------------------------------------------------------------
4721
4722 static struct MUI_NListtree_TreeNode *MoveMenuTree(struct MenuPrefsInst *inst,
4723 ULONG DestListtreeIndex, ULONG SrcListtreeIndex, ULONG EntryIndex)
4724 {
4725 struct MUI_NListtree_TreeNode *NewNode = NULL;
4726
4727 if (inst->mpb_PopMenuNode[EntryIndex].mpn_ListNode &&
4728 inst->mpb_PopMenuNode[EntryIndex].mpn_Listtree == inst->mpb_Objects[SrcListtreeIndex])
4729 {
4730 // Create new entry in dest listtree
4731 NewNode = CopyMenuEntry(inst,
4732 inst->mpb_Objects[DestListtreeIndex],
4733 inst->mpb_Objects[SrcListtreeIndex],
4734 inst->mpb_PopMenuNode[EntryIndex].mpn_ListNode,
4735 MUIV_NListtree_Insert_ListNode_Root);
4736 if (NewNode)
4737 {
4738 // remove old entry (w/ subentries) from src listtree
4739 DoMethod(inst->mpb_PopMenuNode[EntryIndex].mpn_Listtree,
4740 MUIM_NListtree_Remove,
4741 MUIV_NListtree_Remove_ListNode_Root,
4742 inst->mpb_PopMenuNode[EntryIndex].mpn_ListNode,
4743 0);
4744
4745 // remember new entry
4746 inst->mpb_PopMenuNode[EntryIndex].mpn_Listtree = inst->mpb_Objects[DestListtreeIndex];
4747 inst->mpb_PopMenuNode[EntryIndex].mpn_ListNode = NewNode;
4748 }
4749 }
4750
4751 return NewNode;
4752 }
4753
4754 //----------------------------------------------------------------------------
4755
4756 static struct MUI_NListtree_TreeNode *CopyFileTypesEntry(struct MenuPrefsInst *inst,
4757 struct MUI_NListtree_TreeNode *tnToListNode, struct MUI_NListtree_TreeNode *tnToPrevNode,
4758 struct MUI_NListtree_TreeNode *tnFrom, ULONG destList, ULONG srcList)
4759 {
4760 struct MenuListEntry *mleFrom = (struct MenuListEntry *) tnFrom->tn_User;
4761 struct MenuListEntry *mleTo;
4762 struct MUI_NListtree_TreeNode *tnNew;
4763 struct MUI_NListtree_TreeNode *tnChild;
4764 struct MenuInsertEntry mie;
4765 struct ScalosMenuTree mTree;
4766 STRPTR IconNames = NULL;
4767
4768 memset(&mTree, 0, sizeof(mTree));
4769 mie.mie_TreeEntry = &mTree;
4770
4771 if (NULL == tnFrom)
4772 return NULL;
4773
4774 tnChild = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[srcList],
4775 MUIM_NListtree_GetEntry,
4776 tnFrom,
4777 MUIV_NListtree_GetEntry_Position_Head,
4778 0);
4779
4780 mTree.mtre_type = mleFrom->llist_EntryType;
4781 mie.mie_MenuFlags = mleFrom->llist_Flags;
4782
4783 switch (mleFrom->llist_EntryType)
4784 {
4785 case SCAMENUTYPE_Menu:
4786 case SCAMENUTYPE_ToolsMenu:
4787 case SCAMENUTYPE_MenuItem:
4788 stccpy(mTree.MenuCombo.MenuTree.mtre_hotkey, mleFrom->llist_HotKey,
4789 sizeof(mTree.MenuCombo.MenuTree.mtre_hotkey));
4790
4791 if (strlen(mleFrom->llist_UnselectedIconName) > 0
4792 || strlen(mleFrom->llist_SelectedIconName) > 0)
4793 {
4794 size_t len = 2 + strlen(mleFrom->llist_UnselectedIconName) + strlen(mleFrom->llist_SelectedIconName);
4795
4796 IconNames = malloc(len);
4797 if (IconNames)
4798 {
4799 strcpy(IconNames, mleFrom->llist_UnselectedIconName);
4800 strcpy(IconNames + 1 + strlen(IconNames), mleFrom->llist_SelectedIconName);
4801
4802 mTree.mtre_flags |= MTREFLGF_IconNames;
4803 }
4804 }
4805 break;
4806 case SCAMENUTYPE_Command:
4807 mTree.MenuCombo.MenuCommand.mcom_type = mleFrom->llist_CommandType;
4808 mTree.MenuCombo.MenuCommand.mcom_flags = mleFrom->llist_CommandFlags;
4809 mTree.MenuCombo.MenuCommand.mcom_pri = mleFrom->llist_Priority;
4810 mTree.MenuCombo.MenuCommand.mcom_stack = mleFrom->llist_Stack;
4811 break;
4812 default:
4813 break;
4814 }
4815
4816 tnNew = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[destList],
4817 MUIM_NListtree_Insert,
4818 tnFrom->tn_Name,
4819 &mie,
4820 tnToListNode,
4821 tnToPrevNode,
4822 tnFrom->tn_Flags);
4823
4824 if (IconNames)
4825 free(IconNames);
4826
4827 mleTo = (struct MenuListEntry *) tnNew->tn_User;
4828
4829 *mleTo = *mleFrom;
4830
4831 // Copy Children
4832 while (tnChild)
4833 {
4834 d1(kprintf("%s/%ld: tnChild=%08lx <%s>\n", __FUNC__, __LINE__, tnChild, tnChild->tn_Name));
4835
4836 CopyFileTypesEntry(inst,
4837 tnNew, (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail,
4838 tnChild, destList, srcList);
4839
4840 tnChild = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[srcList],
4841 MUIM_NListtree_GetEntry,
4842 tnChild,
4843 MUIV_NListtree_GetEntry_Position_Next,
4844 0);
4845 }
4846
4847 return tnNew;
4848 }
4849
4850 //----------------------------------------------------------------------------
4851
4852 static LONG CopyMenuTree(struct MenuPrefsInst *inst,
4853 Object *ListTreeDest, Object *ListTreeSrc,
4854 struct MUI_NListtree_TreeNode *Src, struct MUI_NListtree_TreeNode *DestParent)
4855 {
4856 LONG Result = RETURN_OK;
4857
4858 d1(KPrintF("%s/%s/%ld: START\n", __FILE__, __FUNC__, __LINE__));
4859
4860 while (Src)
4861 {
4862 CopyMenuEntry(inst, ListTreeDest, ListTreeSrc, Src, DestParent);
4863
4864 Src = (struct MUI_NListtree_TreeNode *) DoMethod(ListTreeSrc,
4865 MUIM_NListtree_GetEntry,
4866 Src,
4867 MUIV_NListtree_GetEntry_Position_Next,
4868 MUIV_NListtree_GetEntry_Flag_SameLevel);
4869 d1(KPrintF("%s/%s/%ld: Src=%08lx\n", __FILE__, __FUNC__, __LINE__, Src));
4870 }
4871
4872 d1(KPrintF("%s/%s/%ld: END Result=%ld\n", __FILE__, __FUNC__, __LINE__, Result));
4873
4874 return Result;
4875 }
4876
4877 //----------------------------------------------------------------------------
4878
4879 static struct MUI_NListtree_TreeNode *CopyMenuEntry(struct MenuPrefsInst *inst,
4880 Object *ListTreeDest, Object *ListTreeSrc,
4881 struct MUI_NListtree_TreeNode *Src, struct MUI_NListtree_TreeNode *DestParent)
4882 {
4883 const struct MenuListEntry *mleSrc = (struct MenuListEntry *) Src->tn_User;
4884 struct MUI_NListtree_TreeNode *NewNode;
4885
4886 d1(KPrintF("%s/%s/%ld: TreeNode=%08lx <%s> DestParent=%08lx\n", \
4887 __FILE__, __FUNC__, __LINE__, Src, Src->tn_Name ? Src->tn_Name : (STRPTR) "===BAR===", DestParent));
4888
4889 NewNode = (struct MUI_NListtree_TreeNode *) DoMethod(ListTreeDest,
4890 MUIM_NListtree_Insert, Src->tn_Name,
4891 0,
4892 DestParent,
4893 MUIV_NListtree_Insert_PrevNode_Tail,
4894 Src->tn_Flags);
4895 if (NewNode)
4896 {
4897 struct MenuListEntry *mleDest = (struct MenuListEntry *) NewNode->tn_User;
4898 struct MUI_NListtree_TreeNode *SubNode;
4899
4900 // Clone entry
4901 *mleDest = *mleSrc;
4902
4903 SubNode = (struct MUI_NListtree_TreeNode *) DoMethod(ListTreeSrc,
4904 MUIM_NListtree_GetEntry,
4905 Src,
4906 MUIV_NListtree_GetEntry_Position_Head,
4907 0);
4908
4909 d1(KPrintF("%s/%s/%ld: SubNode=%08lx\n", __FILE__, __FUNC__, __LINE__, SubNode));
4910 if (SubNode)
4911 {
4912 CopyMenuTree(inst,
4913 ListTreeDest,
4914 ListTreeSrc,
4915 SubNode,
4916 NewNode);
4917 }
4918 }
4919
4920 return NewNode;
4921 }
4922
4923 //----------------------------------------------------------------------------
4924
4925 static void EnableCommandArgumentGadgets(struct MenuPrefsInst *inst, const struct MenuListEntry *mle)
4926 {
4927 switch (mle->llist_CommandType)
4928 {
4929 case SCAMENUCMDTYPE_AmigaDOS:
4930 case SCAMENUCMDTYPE_Workbench:
4931 set(inst->mpb_Objects[OBJNDX_CheckArgs], MUIA_Disabled, FALSE);
4932 set(inst->mpb_Objects[OBJNDX_CheckArgs], MUIA_Selected, (mle->llist_CommandFlags & MCOMFLGF_Args));
4933 set(inst->mpb_Objects[OBJNDX_SliderPriority], MUIA_Disabled, FALSE);
4934 set(inst->mpb_Objects[OBJNDX_StringStack], MUIA_Disabled, FALSE);
4935 break;
4936
4937 case SCAMENUCMDTYPE_Command:
4938 case SCAMENUCMDTYPE_IconWindow:
4939 case SCAMENUCMDTYPE_ARexx:
4940 case SCAMENUCMDTYPE_Plugin:
4941 set(inst->mpb_Objects[OBJNDX_CheckArgs], MUIA_Disabled, TRUE);
4942 set(inst->mpb_Objects[OBJNDX_CheckArgs], MUIA_Selected, FALSE);
4943 set(inst->mpb_Objects[OBJNDX_SliderPriority], MUIA_Disabled, TRUE);
4944 set(inst->mpb_Objects[OBJNDX_StringStack], MUIA_Disabled, TRUE);
4945 break;
4946 }
4947 }
4948
4949 //----------------------------------------------------------------------------
4950
4951 static BOOL IsPopupMenu(struct MenuPrefsInst *inst, struct MUI_NListtree_TreeNode *TreeNode)
4952 {
4953 struct MUI_NListtree_TreeNode *ParentNode;
4954 BOOL IsPopupMenu = FALSE;
4955
4956 // find root of this TreeNode
4957 ParentNode = TreeNode;
4958 while (ParentNode)
4959 {
4960 if (inst->mpb_MainMenuNode.mpn_ListNode != ParentNode)
4961 {
4962 short n;
4963
4964 for (n = 0; n < Sizeof(inst->mpb_PopMenuNode); n++)
4965 {
4966 if (inst->mpb_PopMenuNode[n].mpn_ListNode == ParentNode)
4967 {
4968 IsPopupMenu = TRUE;
4969 break;
4970 }
4971 }
4972 }
4973
4974 ParentNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
4975 MUIM_NListtree_GetEntry, ParentNode, MUIV_NListtree_GetEntry_Position_Parent, 0);
4976
4977 d1(kprintf("%s/%s/%ld: Parent=%08lx\n", __FILE__, __FUNC__, __LINE__, ParentNode));
4978 }
4979
4980 return IsPopupMenu;
4981 }
4982
4983 //----------------------------------------------------------------------------
4984
4985 static enum MenuEntryType GetMenuEntryType(struct MenuPrefsInst *inst,
4986 struct MUI_NListtree_TreeNode *TreeNode)
4987 {
4988 struct MenuListEntry *mle = (struct MenuListEntry *) TreeNode->tn_User;
4989 struct MUI_NListtree_TreeNode *ParentNode;
4990 BOOL IsMainMenu = FALSE;
4991 BOOL IsPopupMenu = FALSE;
4992 ULONG Level = 0;
4993
4994 if (NULL == mle)
4995 return MENUENTRY_Invalid;
4996
4997 if (SCAMENUTYPE_Command == mle->llist_EntryType)
4998 {
4999 // Get parent menu entry for command
5000 TreeNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
5001 MUIM_NListtree_GetEntry, TreeNode, MUIV_NListtree_GetEntry_Position_Parent, 0);
5002
5003 mle = (struct MenuListEntry *) TreeNode->tn_User;
5004 }
5005
5006 // find root of this TreeNode
5007 ParentNode = TreeNode;
5008 while (ParentNode)
5009 {
5010 if (inst->mpb_MainMenuNode.mpn_ListNode == ParentNode)
5011 IsMainMenu = TRUE;
5012 else
5013 {
5014 short n;
5015
5016 for (n = 0; n < Sizeof(inst->mpb_PopMenuNode); n++)
5017 {
5018 if (inst->mpb_PopMenuNode[n].mpn_ListNode == ParentNode)
5019 {
5020 IsPopupMenu = TRUE;
5021 break;
5022 }
5023 }
5024 }
5025
5026 Level++;
5027
5028 ParentNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
5029 MUIM_NListtree_GetEntry, ParentNode, MUIV_NListtree_GetEntry_Position_Parent, 0);
5030
5031 d1(kprintf("%s/%s/%ld: Parent=%08lx\n", __FILE__, __FUNC__, __LINE__, ParentNode));
5032 }
5033
5034 if (IsMainMenu)
5035 {
5036 Level -= 2;
5037 // Level 0 = MainMenu
5038 // Level 1 = Menu entry
5039 // Level 2 = MenuItem
5040 // Level 3 = SubItem
5041 }
5042 else if (IsPopupMenu)
5043 {
5044 Level--;
5045 // Level 1 = Popup Menu
5046 // Level 2 = MenuItem
5047 // Level 3 = SubItem
5048 }
5049 else
5050 return MENUENTRY_Invalid;
5051
5052 d1(kprintf("%s/%s/%ld: IsMainMenu=%ld IsPopupMenu=%ld Level=%ld\n", \
5053 __FILE__, __FUNC__, __LINE__, IsMainMenu, IsPopupMenu, Level));
5054
5055 switch (mle->llist_EntryType)
5056 {
5057 case SCAMENUTYPE_Menu:
5058 case SCAMENUTYPE_MainMenu:
5059 case SCAMENUTYPE_ToolsMenu:
5060 Level++; // Check applies to Menu children
5061 break;
5062 default:
5063 break;
5064 }
5065
5066 switch (Level)
5067 {
5068 case 1: // Menu
5069 return MENUENTRY_Menu;
5070 break;
5071 case 2: // MenuItem
5072 return MENUENTRY_MenuItem;
5073 break;
5074 case 3: // SubItem
5075 return MENUENTRY_SubItem;
5076 break;
5077 default: // should never occur
5078 return MENUENTRY_Invalid;
5079 break;
5080 }
5081 }
5082
5083 //----------------------------------------------------------------------------
5084
5085 static ULONG GetMaxCountForEntry(enum MenuEntryType type)
5086 {
5087 switch (type)
5088 {
5089 case MENUENTRY_Menu:
5090 return MAX_MENU;
5091 break;
5092 case MENUENTRY_MenuItem:
5093 return MAX_MENUITEM;
5094 break;
5095 case MENUENTRY_SubItem:
5096 return MAX_SUBITEM;
5097 break;
5098 default:
5099 return 0;
5100 break;
5101 }
5102 }
5103
5104 //----------------------------------------------------------------------------
5105
5106 void _XCEXIT(long x)
5107 {
5108 }
5109
5110 //----------------------------------------------------------------------------
5111
5112 static void SwitchPopButton(struct MenuPrefsInst *inst, UBYTE CommandType)
5113 {
5114 if (SCAMENUCMDTYPE_Command == CommandType)
5115 {
5116 set(inst->mpb_Objects[OBJNDX_PopObject], MUIA_ShowMe, TRUE);
5117 set(inst->mpb_Objects[OBJNDX_Popbutton], MUIA_ShowMe, FALSE);
5118 }
5119 else
5120 {
5121 set(inst->mpb_Objects[OBJNDX_PopObject], MUIA_ShowMe, FALSE);
5122 set(inst->mpb_Objects[OBJNDX_Popbutton], MUIA_ShowMe, TRUE);
5123 }
5124
5125 }
5126
5127 //----------------------------------------------------------------------------
5128
5129 DISPATCHER(myNListTree)
5130 {
5131 struct MenuPrefsInst *inst = NULL;
5132 ULONG Result;
5133
5134 d1(kprintf("%s/%s/%ld: MethodID=%08lx\n", __FILE__, __FUNC__, __LINE__, msg->MethodID));
5135
5136 switch(msg->MethodID)
5137 {
5138 case MUIM_ContextMenuChoice:
5139 {
5140 struct MUIP_ContextMenuChoice *cmc = (struct MUIP_ContextMenuChoice *) msg;
5141 Object *MenuObj;
5142 ULONG MenuHookIndex = 0;
5143 struct Hook *MenuHook = NULL;
5144
5145 get(obj, MUIA_NList_PrivateData, &inst);
5146
5147 d1(kprintf("%s/%s//%ld: MUIM_ContextMenuChoice item=%08lx\n", __FILE__, __FUNC__, __LINE__, cmc->item));
5148
5149 MenuObj = cmc->item;
5150
5151 d1(kprintf("%s/%s//%ld: MenuObj=%08lx\n", __FILE__, __FUNC__, __LINE__, MenuObj));
5152 d1(kprintf("%s/%s//%ld: msg=%08lx *msg=%08lx\n", __FILE__, __FUNC__, __LINE__, msg, *((ULONG *) msg)));
5153
5154 get(MenuObj, MUIA_UserData, &MenuHookIndex);
5155
5156 if (MenuHookIndex > 0 && MenuHookIndex < HOOKNDX_MAX)
5157 MenuHook = &inst->mpb_Hooks[MenuHookIndex];
5158
5159 d1(kprintf("%s/%s//%ld: MenuHook=%08lx\n", __FILE__, __FUNC__, __LINE__, MenuHook));
5160 if (MenuHook)
5161 DoMethod(inst->mpb_Objects[OBJNDX_Group_Main], MUIM_CallHook, MenuHook, 0);
5162
5163 Result = 0;
5164 }
5165 break;
5166
5167 case MUIM_NList_TestPos:
5168 {
5169 struct TestPosArg
5170 {
5171 ULONG MethodID;
5172 LONG x, y;
5173 struct MUI_NList_TestPos_Result *res;
5174 };
5175 struct TestPosArg *tpa = (struct TestPosArg *) msg;
5176
5177 get(obj, MUIA_NList_PrivateData, &inst);
5178
5179 if (inst->mpb_PageIsActive)
5180 Result = DoSuperMethodA(cl, obj, msg);
5181 else
5182 {
5183 Result = 0;
5184 tpa->res->entry = tpa->res->column = -1;
5185 }
5186
5187 d1(kprintf("%s/%s//%ld: MUIM_NList_TestPos Result=%08lx x=%ld y=%ld tpr=%08lx entry=%ld column=%ld\n", \
5188 __FILE__, __FUNC__, __LINE__, Result, tpa->x, tpa->y, tpa->res, tpa->res->entry, tpa->res->column));
5189 }
5190 break;
5191
5192 case MUIM_DragDrop:
5193 get(obj, MUIA_NList_PrivateData, &inst);
5194 SetChangedFlag(inst, TRUE);
5195 Result = DoSuperMethodA(cl, obj, msg);
5196 break;
5197
5198 case MUIM_NList_DropType:
5199 {
5200 struct MUIP_NList_DropType *dr = (struct MUIP_NList_DropType *)msg;
5201 struct MUI_NListtree_TreeNode *tnTo, *tnFrom;
5202 struct MUI_NListtree_TestPos_Result res;
5203
5204 get(obj, MUIA_NList_PrivateData, &inst);
5205
5206 inst->mpb_MenuTreeMayDrop = FALSE;
5207
5208 Result = DoSuperMethodA(cl, obj, msg);
5209 d1(KPrintF("%s/%ld: DropType=%ld pos=%ld\n", __FUNC__, __LINE__, *(dr->type), *(dr->pos)));
5210
5211 DoMethod(obj, MUIM_NListtree_TestPos, dr->mousex, dr->mousey, &res);
5212
5213 tnTo = res.tpr_TreeNode;
5214
5215 tnFrom = MUIV_NListtree_Active_Off;
5216 get(obj, MUIA_NListtree_Active, &tnFrom);
5217
5218 d1(KPrintF("%s/%ld: tnFrom=%08lx tnTo=%08lx\n", __FUNC__, __LINE__, tnFrom, tnTo));
5219
5220 if (tnTo && tnFrom)
5221 {
5222 switch (*(dr->type))
5223 {
5224 case MUIV_NListtree_DropType_None:
5225 case MUIV_NListtree_DropType_Sorted:
5226 default:
5227 break;
5228 case MUIV_NListtree_DropType_Above:
5229 case MUIV_NListtree_DropType_Below:
5230 if (MayPasteBelow(inst, tnTo, tnFrom))
5231 inst->mpb_MenuTreeMayDrop = TRUE;
5232 break;
5233 case MUIV_NListtree_DropType_Onto:
5234 if (MayPasteOnto(inst, tnTo, tnFrom))
5235 inst->mpb_MenuTreeMayDrop = TRUE;
5236 break;
5237 }
5238 d1(KPrintF("%s/%ld: DropType=%ld\n", __FUNC__, __LINE__, *(dr->type)));
5239 }
5240 }
5241 break;
5242
5243 // we catch MUIM_DragReport because we want to restrict some dragging for some special objects
5244 case MUIM_DragReport:
5245 {
5246 get(obj, MUIA_NList_PrivateData, &inst);
5247
5248 d1(KPrintF("%s/%ld: MUIM_DragReport\n", __FUNC__, __LINE__));
5249
5250 Result = DoSuperMethodA(cl, obj, msg);
5251 if (!inst->mpb_MenuTreeMayDrop)
5252 Result = MUIV_DragReport_Abort;
5253
5254 d1(KPrintF("%s/%ld: MUIM_DragReport\n", __FUNC__, __LINE__));
5255 }
5256 break;
5257 default:
5258 Result = DoSuperMethodA(cl, obj, msg);
5259 }
5260
5261 return Result;
5262 }
5263 DISPATCHER_END
5264
5265
5266 static Object *CreatePrefsImage(void)
5267 {
5268 #include "MenuPrefsImage.h"
5269 Object *img;
5270
5271 // First try to load datatypes image from THEME: tree
5272 img = DataTypesImageObject,
5273 MUIA_ScaDtpic_Name, (ULONG) "THEME:prefs/plugins/menu",
5274 MUIA_ScaDtpic_FailIfUnavailable, TRUE,
5275 End; //DataTypesMCCObject
5276
5277 if (NULL == img)
5278 img = IMG(MenuPrefs, MENUPREFS); // use built-in fallback image
5279
5280 return img;
5281 }
5282
5283
5284 static void InitHooks(struct MenuPrefsInst *inst)
5285 {
5286 ULONG n;
5287
5288 for (n=0; n<HOOKNDX_MAX; n++)
5289 {
5290 inst->mpb_Hooks[n] = MenuPrefsHooks[n];
5291 inst->mpb_Hooks[n].h_Data = inst;
5292 }
5293 }
5294
5295
5296 static void SetChangedFlag(struct MenuPrefsInst *inst, BOOL changed)
5297 {
5298 if (changed != inst->mpb_Changed)
5299 {
5300 set(inst->mpb_Objects[OBJNDX_Lamp_Changed],
5301 MUIA_Lamp_Color, changed ? MUIV_Lamp_Color_Ok : MUIV_Lamp_Color_Off);
5302 inst->mpb_Changed = changed;
5303 }
5304 }
5305
5306
5307 static void AddDefaultMenuContents(struct MenuPrefsInst *inst)
5308 {
5309 ULONG n;
5310 struct MUI_NListtree_TreeNode *LastNode[4];
5311 Object *Listtree = NULL;
5312 struct MenuInsertEntry mie;
5313 struct ScalosMenuTree mTree;
5314
5315 mie.mie_TreeEntry = &mTree;
5316
5317 inst->mpb_QuietFlag = TRUE;
5318
5319 for (n = 0; n < DefaultMenuEntries; n++)
5320 {
5321 struct MUI_NListtree_TreeNode *ParentNode;
5322 CONST_STRPTR MenuName;
5323 struct MUI_NListtree_TreeNode *NewNode;
5324 struct MenuListEntry *mle;
5325 ULONG InsertFlags;
5326
5327 memset(&mTree, 0, sizeof(mTree));
5328
5329 switch (DefaultMenu[n].dme_ParentNode)
5330 {
5331 case DEFAULTPARENTNODE_MainMenu:
5332 Listtree = inst->mpb_MainMenuNode.mpn_Listtree;
5333 ParentNode = inst->mpb_MainMenuNode.mpn_ListNode;
5334 d1(KPrintF("%s/%s//%ld: DEFAULTPARENTNODE_MainMenu Listtree=%08lx\n", __FILE__, __FUNC__, __LINE__, Listtree));
5335 break;
5336 case DEFAULTPARENTNODE_Popup_Disk:
5337 Listtree = inst->mpb_PopMenuNode[POPMENUINDEX_Disk].mpn_Listtree;
5338 ParentNode = inst->mpb_PopMenuNode[POPMENUINDEX_Disk].mpn_ListNode;
5339 d1(KPrintF("%s/%s//%ld:DEFAULTPARENTNODE_Popup_Disk Listtree=%08lx\n", __FILE__, __FUNC__, __LINE__, Listtree));
5340 break;
5341 case DEFAULTPARENTNODE_Popup_Drawer:
5342 Listtree = inst->mpb_PopMenuNode[POPMENUINDEX_Drawer].mpn_Listtree;
5343 ParentNode = inst->mpb_PopMenuNode[POPMENUINDEX_Drawer].mpn_ListNode;
5344 d1(KPrintF("%s/%s//%ld: DEFAULTPARENTNODE_Popup_Drawer Listtree=%08lx\n", __FILE__, __FUNC__, __LINE__, Listtree));
5345 break;
5346 case DEFAULTPARENTNODE_Popup_ToolProject:
5347 Listtree = inst->mpb_PopMenuNode[POPMENUINDEX_ToolProject].mpn_Listtree;
5348 ParentNode = inst->mpb_PopMenuNode[POPMENUINDEX_ToolProject].mpn_ListNode;
5349 d1(KPrintF("%s/%s//%ld: DEFAULTPARENTNODE_Popup_ToolProject Listtree=%08lx\n", __FILE__, __FUNC__, __LINE__, Listtree));
5350 break;
5351 case DEFAULTPARENTNODE_Popup_Trashcan:
5352 Listtree = inst->mpb_PopMenuNode[POPMENUINDEX_ToolProject].mpn_Listtree;
5353 ParentNode = inst->mpb_PopMenuNode[POPMENUINDEX_Trashcan].mpn_ListNode;
5354 d1(KPrintF("%s/%s//%ld: DEFAULTPARENTNODE_Popup_Trashcan Listtree=%08lx\n", __FILE__, __FUNC__, __LINE__, Listtree));
5355 break;
5356 case DEFAULTPARENTNODE_Popup_Window:
5357 Listtree = inst->mpb_PopMenuNode[POPMENUINDEX_Window].mpn_Listtree;
5358 ParentNode = inst->mpb_PopMenuNode[POPMENUINDEX_Window].mpn_ListNode;
5359 d1(KPrintF("%s/%s//%ld: DEFAULTPARENTNODE_Popup_Window Listtree=%08lx\n", __FILE__, __FUNC__, __LINE__, Listtree));
5360 break;
5361 case DEFAULTPARENTNODE_Popup_AppIcon:
5362 Listtree = inst->mpb_PopMenuNode[POPMENUINDEX_AppIcon].mpn_Listtree;
5363 ParentNode = inst->mpb_PopMenuNode[POPMENUINDEX_AppIcon].mpn_ListNode;
5364 d1(KPrintF("%s/%s//%ld: DEFAULTPARENTNODE_Popup_AppIcon Listtree=%08lx\n", __FILE__, __FUNC__, __LINE__, Listtree));
5365 break;
5366 case DEFAULTPARENTNODE_Popup_Desktop:
5367 Listtree = inst->mpb_PopMenuNode[POPMENUINDEX_Desktop].mpn_Listtree;
5368 ParentNode = inst->mpb_PopMenuNode[POPMENUINDEX_Desktop].mpn_ListNode;
5369 d1(KPrintF("%s/%s//%ld: DEFAULTPARENTNODE_Popup_Desktop Listtree=%08lx\n", __FILE__, __FUNC__, __LINE__, Listtree));
5370 break;
5371 case DEFAULTPARENTNODE_LastInsertedMenu:
5372 case DEFAULTPARENTNODE_LastInsertedMenuItem:
5373 ParentNode = LastNode[DefaultMenu[n].dme_Level - 1];
5374 break;
5375 case DEFAULTPARENTNODE_LastInserted:
5376 default:
5377 ParentNode = (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_ListNode_LastInserted;
5378 break;
5379 }
5380
5381 InsertFlags = MUIV_NListtree_Insert_Flag_Active;
5382
5383 if (SCAMENUTYPE_Command == DefaultMenu[n].dme_EntryType)
5384 {
5385 MenuName = (CONST_STRPTR) DefaultMenu[n].dme_NameId;
5386 mTree.MenuCombo.MenuCommand.mcom_name = (STRPTR) MenuName;
5387 }
5388 else
5389 {
5390 if (DefaultMenu[n].dme_NameId)
5391 MenuName = GetLocString(DefaultMenu[n].dme_NameId);
5392 else
5393 MenuName = "";
5394 InsertFlags |= TNF_OPEN | TNF_LIST;
5395 }
5396
5397 d1(KPrintF("%s/%s//%ld: Listtree=%08lx ParentNode=%08lx\n", __FILE__, __FUNC__, __LINE__, Listtree, ParentNode));
5398
5399 mTree.mtre_type = DefaultMenu[n].dme_EntryType;
5400 mie.mie_MenuFlags = 0;
5401
5402 switch (DefaultMenu[n].dme_EntryType)
5403 {
5404 case SCAMENUTYPE_Menu:
5405 case SCAMENUTYPE_ToolsMenu:
5406 case SCAMENUTYPE_MenuItem:
5407 stccpy(mTree.MenuCombo.MenuTree.mtre_hotkey, GetLocString(DefaultMenu[n].dme_MenuShortId), sizeof(mle->llist_HotKey));
5408 break;
5409 case SCAMENUTYPE_Command:
5410 mTree.MenuCombo.MenuCommand.mcom_type = DefaultMenu[n].dme_CmdType;
5411 mTree.MenuCombo.MenuCommand.mcom_flags = DefaultMenu[n].dme_CmdFlags;
5412 mTree.MenuCombo.MenuCommand.mcom_pri = DefaultMenu[n].dme_CmdPri;
5413 mTree.MenuCombo.MenuCommand.mcom_stack = DefaultMenu[n].dme_CmdStackSize;
5414 break;
5415 default:
5416 break;
5417 }
5418
5419 DoMethod(Listtree,
5420 MUIM_NListtree_Insert, MenuName,
5421 &mie,
5422 ParentNode,
5423 MUIV_NListtree_Insert_PrevNode_Tail,
5424 InsertFlags);
5425
5426 d1(KPrintF("%s/%s//%ld: Listtree=%08lx NewNode=%08lx\n", __FILE__, __FUNC__, __LINE__, Listtree, NewNode));
5427 NewNode = (struct MUI_NListtree_TreeNode *) DoMethod(Listtree,
5428 MUIM_NListtree_GetEntry,
5429 ParentNode,
5430 MUIV_NListtree_GetEntry_Position_Tail, 0);
5431 d1(KPrintF("%s/%s//%ld: Listtree=%08lx NewNode=%08lx\n", __FILE__, __FUNC__, __LINE__, Listtree, NewNode));
5432 if (NewNode)
5433 mle = (struct MenuListEntry *) NewNode->tn_User;
5434 else
5435 mle = NULL;
5436
5437 if (mle)
5438 {
5439 switch (DefaultMenu[n].dme_EntryType)
5440 {
5441 case SCAMENUTYPE_Menu:
5442 case SCAMENUTYPE_ToolsMenu:
5443 case SCAMENUTYPE_MenuItem:
5444 LastNode[DefaultMenu[n].dme_Level] = NewNode;
5445 break;
5446 default:
5447 break;
5448 }
5449 }
5450 }
5451
5452 inst->mpb_QuietFlag = FALSE;
5453 }
5454
5455 //-----------------------------------------------------------------
5456
5457 static void ParseToolTypes(struct MenuPrefsInst *inst, struct MUIP_ScalosPrefs_ParseToolTypes *ptt)
5458 {
5459 STRPTR tt;
5460
5461 d1(kprintf("%s/%ld: start ptt=%08lx tooltypes=%08lx\n", __FUNC__, __LINE__, ptt, ptt->ToolTypes));
5462 d1(kprintf("%s/%ld: start tooltypes=%08lx %08lx %08lx\n", __FUNC__, __LINE__, ptt, ptt->ToolTypes[0], ptt->ToolTypes[1], ptt->ToolTypes[2]));
5463
5464 tt = FindToolType(ptt->ToolTypes, "HIDEOBSOLETE");
5465 d1(kprintf("%s/%ld: tt=%08lx\n", __FUNC__, __LINE__, tt));
5466 if (tt)
5467 {
5468 d1(kprintf("%s/%ld:\n", __FUNC__, __LINE__));
5469
5470 if (MatchToolValue(tt, "YES"))
5471 inst->mpb_HideObsoletePopupMenus = TRUE;
5472 else if (MatchToolValue(tt, "NO"))
5473 inst->mpb_HideObsoletePopupMenus = FALSE;
5474
5475 d1(kprintf("%s/%ld:\n", __FUNC__, __LINE__));
5476 }
5477
5478 if (inst->mpb_Objects[OBJNDX_Menu_HideObsolete])
5479 set(inst->mpb_Objects[OBJNDX_Menu_HideObsolete], MUIA_Menuitem_Checked, inst->mpb_HideObsoletePopupMenus);
5480
5481 CallHookPkt(&inst->mpb_Hooks[HOOKNDX_HideObsolete],
5482 inst->mpb_Objects[OBJNDX_APP_Main], 0);
5483
5484 d1(kprintf("%s/%ld: end\n", __FUNC__, __LINE__));
5485 }
5486
5487 //----------------------------------------------------------------------------
5488
5489 BOOL initPlugin(struct PluginBase *PluginBase)
5490 {
5491 ULONG n;
5492
5493 MajorVersion = PluginBase->pl_LibNode.lib_Version;
5494 MinorVersion = PluginBase->pl_LibNode.lib_Revision;
5495
5496 d1(kprintf("%s/%s//%ld:\n", __FILE__, __FUNC__, __LINE__));
5497
5498 d1(kprintf("%s/%s//%ld: MenuPrefsLibBase=%08lx procName=<%s>\n", __FILE__, __FUNC__, __LINE__, \
5499 PluginBase, FindTask(NULL)->tc_Node.ln_Name));
5500
5501 d1(kprintf("%s/%s//%ld:\n", __FILE__, __FUNC__, __LINE__));
5502
5503 if (!OpenLibraries())
5504 return FALSE;
5505
5506 d1(kprintf("%s/%s//%ld:\n", __FILE__, __FUNC__, __LINE__));
5507
5508 #if !defined(__amigaos4__) && !defined(__AROS__)
5509 if (_STI_240_InitMemFunctions())
5510 return FALSE;
5511 #endif
5512
5513 d1(kprintf("%s/%s//%ld:\n", __FILE__, __FUNC__, __LINE__));
5514
5515 MenuPrefsClass = MUI_CreateCustomClass(&PluginBase->pl_LibNode, MUIC_Group,
5516 NULL, sizeof(struct MenuPrefsInst), DISPATCHER_REF(MenuPrefs));
5517
5518 d1(kprintf("%s/%s//%ld: MenuPrefsClass=%08lx\n", __FILE__, __FUNC__, __LINE__, MenuPrefsClass));
5519 if (NULL == MenuPrefsClass)
5520 return FALSE;
5521
5522 for (n=0; n<Sizeof(CommandsTable); n++)
5523 CommandsArray[n] = &CommandsTable[n];
5524 CommandsArray[Sizeof(CommandsTable)] = NULL;
5525
5526 d1(KPrintF("%s/%s//%ld:\n", __FILE__, __FUNC__, __LINE__));
5527
5528 if (LocaleBase)
5529 {
5530 if (NULL == MenuPrefsLocale)
5531 MenuPrefsLocale = OpenLocale(NULL);
5532
5533 if (MenuPrefsLocale)
5534 {
5535 if (NULL == MenuPrefsCatalog)
5536 {
5537 MenuPrefsCatalog = OpenCatalog(MenuPrefsLocale,
5538 (STRPTR) "Scalos/ScalosMenu.catalog", NULL);
5539 }
5540 }
5541 }
5542
5543 if (!StaticsTranslated)
5544 {
5545 StaticsTranslated = TRUE;
5546
5547 TranslateStringArray(CmdModeStrings);
5548 TranslateNewMenu(ContextMenus);
5549 }
5550
5551 if (NULL == myNListTreeClass)
5552 {
5553 myNListTreeClass = MUI_CreateCustomClass(NULL, MUIC_NListtree,
5554 NULL, 0, DISPATCHER_REF(myNListTree));
5555 }
5556
5557 d1(KPrintF("%s/%s//%ld: myNListTreeClass=%08lx\n", __FILE__, __FUNC__, __LINE__, myNListTreeClass));
5558
5559 if (NULL == myNListTreeClass)
5560 return FALSE; // Failure
5561
5562 if (NULL == DataTypesImageClass)
5563 DataTypesImageClass = InitDtpicClass();
5564
5565 d1(KPrintF("%s/%s//%ld: DataTypesImageClass=%08lx\n", __FILE__, __FUNC__, __LINE__, DataTypesImageClass));
5566
5567 if (NULL == DataTypesImageClass)
5568 return FALSE; // Failure
5569
5570
5571 d1(KPrintF("%s/%s//%ld: success\n", __FILE__, __FUNC__, __LINE__));
5572
5573 return TRUE; // Success
5574 }
5575
5576 //----------------------------------------------------------------------------
5577
5578 static void InsertMenuRootEntries(struct MenuPrefsInst *inst)
5579 {
5580 struct MenuInsertEntry mie;
5581 struct ScalosMenuTree mTree;
5582
5583 memset(&mTree, 0, sizeof(mTree));
5584 mie.mie_TreeEntry = &mTree;
5585 mTree.mtre_type = SCAMENUTYPE_MainMenu;
5586
5587 mie.mie_MenuFlags = LLISTFLGF_NotRemovable | LLISTFLGF_NameNotSetable;
5588 inst->mpb_MainMenuNode.mpn_Listtree = inst->mpb_Objects[OBJNDX_MainListTree];
5589 inst->mpb_MainMenuNode.mpn_ListNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_MainMenuNode.mpn_Listtree,
5590 MUIM_NListtree_Insert, GetLocString(MSGID_MAINMENUNAME),
5591 &mie,
5592 MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail,
5593 MUIV_NListtree_Insert_Flag_Active | TNF_OPEN | TNF_LIST);
5594
5595 mie.mie_MenuFlags = LLISTFLGF_NotRemovable | LLISTFLGF_NameNotSetable | LLISTFLGF_MayNotHaveChildren | LLISTFLGF_PopupMenu;
5596 inst->mpb_PopMenuNode[POPMENUINDEX_Disk].mpn_Listtree = GetMenuEntryListtree(inst);
5597 inst->mpb_PopMenuNode[POPMENUINDEX_Disk].mpn_ListNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_PopMenuNode[POPMENUINDEX_Disk].mpn_Listtree,
5598 MUIM_NListtree_Insert, GetLocString(MSGID_POPMENUNAME1),
5599 &mie,
5600 MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail,
5601 TNF_OPEN | TNF_LIST);
5602
5603 mie.mie_MenuFlags = LLISTFLGF_NotRemovable | LLISTFLGF_NameNotSetable | LLISTFLGF_MayNotHaveChildren | LLISTFLGF_PopupMenu;
5604 inst->mpb_PopMenuNode[POPMENUINDEX_Drawer].mpn_Listtree = GetMenuEntryListtree(inst);
5605 inst->mpb_PopMenuNode[POPMENUINDEX_Drawer].mpn_ListNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_PopMenuNode[POPMENUINDEX_Drawer].mpn_Listtree,
5606 MUIM_NListtree_Insert, GetLocString(MSGID_POPMENUNAME2),
5607 &mie,
5608 MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail,
5609 TNF_OPEN | TNF_LIST);
5610
5611 mie.mie_MenuFlags = LLISTFLGF_NotRemovable | LLISTFLGF_NameNotSetable | LLISTFLGF_MayNotHaveChildren | LLISTFLGF_PopupMenu;
5612 inst->mpb_PopMenuNode[POPMENUINDEX_ToolProject].mpn_Listtree = GetMenuEntryListtree(inst);
5613 inst->mpb_PopMenuNode[POPMENUINDEX_ToolProject].mpn_ListNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_PopMenuNode[POPMENUINDEX_ToolProject].mpn_Listtree,
5614 MUIM_NListtree_Insert, GetLocString(MSGID_POPMENUNAME3),
5615 &mie,
5616 MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail,
5617 TNF_OPEN | TNF_LIST);
5618
5619 mie.mie_MenuFlags = LLISTFLGF_NotRemovable | LLISTFLGF_NameNotSetable | LLISTFLGF_MayNotHaveChildren | LLISTFLGF_PopupMenu;
5620 inst->mpb_PopMenuNode[POPMENUINDEX_Trashcan].mpn_Listtree = GetMenuEntryListtree(inst);
5621 inst->mpb_PopMenuNode[POPMENUINDEX_Trashcan].mpn_ListNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_PopMenuNode[POPMENUINDEX_Trashcan].mpn_Listtree,
5622 MUIM_NListtree_Insert, GetLocString(MSGID_POPMENUNAME4),
5623 &mie,
5624 MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail,
5625 TNF_OPEN | TNF_LIST);
5626
5627 mie.mie_MenuFlags = LLISTFLGF_NotRemovable | LLISTFLGF_NameNotSetable | LLISTFLGF_MayNotHaveChildren | LLISTFLGF_PopupMenu;
5628 inst->mpb_PopMenuNode[POPMENUINDEX_Window].mpn_Listtree = inst->mpb_Objects[OBJNDX_MainListTree];
5629 inst->mpb_PopMenuNode[POPMENUINDEX_Window].mpn_ListNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_PopMenuNode[POPMENUINDEX_Window].mpn_Listtree,
5630 MUIM_NListtree_Insert, GetLocString(MSGID_POPMENUNAME5),
5631 &mie,
5632 MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail,
5633 TNF_OPEN | TNF_LIST);
5634
5635 mie.mie_MenuFlags = LLISTFLGF_NotRemovable | LLISTFLGF_NameNotSetable | LLISTFLGF_MayNotHaveChildren | LLISTFLGF_PopupMenu;
5636 inst->mpb_PopMenuNode[POPMENUINDEX_AppIcon].mpn_Listtree = GetMenuEntryListtree(inst);
5637 inst->mpb_PopMenuNode[POPMENUINDEX_AppIcon].mpn_ListNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_PopMenuNode[POPMENUINDEX_AppIcon].mpn_Listtree,
5638 MUIM_NListtree_Insert, GetLocString(MSGID_POPMENUNAME6),
5639 &mie,
5640 MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail,
5641 TNF_OPEN | TNF_LIST);
5642
5643 mie.mie_MenuFlags = LLISTFLGF_NotRemovable | LLISTFLGF_NameNotSetable | LLISTFLGF_MayNotHaveChildren | LLISTFLGF_PopupMenu;
5644 inst->mpb_PopMenuNode[POPMENUINDEX_Desktop].mpn_Listtree = inst->mpb_Objects[OBJNDX_MainListTree];
5645 inst->mpb_PopMenuNode[POPMENUINDEX_Desktop].mpn_ListNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_PopMenuNode[POPMENUINDEX_Desktop].mpn_Listtree,
5646 MUIM_NListtree_Insert, GetLocString(MSGID_POPMENUNAME7),
5647 &mie,
5648 MUIV_NListtree_Insert_ListNode_Root, MUIV_NListtree_Insert_PrevNode_Tail,
5649 TNF_OPEN | TNF_LIST);
5650 }
5651
5652 //----------------------------------------------------------------------------
5653
5654 static Object *GetMenuEntryListtree(struct MenuPrefsInst *inst)
5655 {
5656 return inst->mpb_Objects[inst->mpb_HideObsoletePopupMenus ? OBJNDX_HiddenListTree : OBJNDX_MainListTree];
5657 }
5658
5659 //----------------------------------------------------------------------------
5660
5661 static struct MUI_NListtree_TreeNode *GetParentNodeForMenu(struct MenuPrefsInst *inst, struct MUI_NListtree_TreeNode **PrevNode)
5662 {
5663 struct MUI_NListtree_TreeNode *ParentNode;
5664 BOOL Finished = FALSE;
5665
5666 *PrevNode = (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail;
5667
5668 ParentNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
5669 MUIM_NListtree_GetEntry, 0, MUIV_NListtree_GetEntry_Position_Active, 0);
5670
5671 while (ParentNode && !Finished)
5672 {
5673 struct MenuListEntry *mle = (struct MenuListEntry *) ParentNode->tn_User;
5674
5675 switch (mle->llist_EntryType)
5676 {
5677 case SCAMENUTYPE_MainMenu:
5678 case SCAMENUTYPE_Menu:
5679 case SCAMENUTYPE_ToolsMenu:
5680 Finished = TRUE;
5681 break;
5682
5683 case SCAMENUTYPE_MenuItem:
5684 case SCAMENUTYPE_Command:
5685 *PrevNode = ParentNode;
5686 ParentNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
5687 MUIM_NListtree_GetEntry, ParentNode,
5688 MUIV_NListtree_GetEntry_Position_Parent, 0);
5689 break;
5690 }
5691 }
5692
5693 return ParentNode;
5694 }
5695
5696 //----------------------------------------------------------------------------
5697
5698 static struct MUI_NListtree_TreeNode *GetParentNodeForMenuItem(struct MenuPrefsInst *inst, struct MUI_NListtree_TreeNode **PrevNode)
5699 {
5700 struct MUI_NListtree_TreeNode *ParentNode;
5701
5702 *PrevNode = (struct MUI_NListtree_TreeNode *) MUIV_NListtree_Insert_PrevNode_Tail;
5703
5704 ParentNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
5705 MUIM_NListtree_GetEntry, 0, MUIV_NListtree_GetEntry_Position_Active, 0);
5706
5707 while (ParentNode)
5708 {
5709 struct MenuListEntry *mle = (struct MenuListEntry *) ParentNode->tn_User;
5710
5711 if ((SCAMENUTYPE_MainMenu == mle->llist_EntryType)
5712 && (mle->llist_Flags & LLISTFLGF_MayNotHaveChildren))
5713 break;
5714
5715 if (SCAMENUTYPE_Menu == mle->llist_EntryType)
5716 break;
5717 if (SCAMENUTYPE_ToolsMenu == mle->llist_EntryType)
5718 break;
5719
5720 *PrevNode = ParentNode;
5721 ParentNode = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
5722 MUIM_NListtree_GetEntry, ParentNode,
5723 MUIV_NListtree_GetEntry_Position_Parent, 0);
5724 }
5725
5726 return ParentNode;
5727 }
5728
5729 //----------------------------------------------------------------------------
5730
5731 static BOOL MayPasteOnto(struct MenuPrefsInst *inst,
5732 struct MUI_NListtree_TreeNode *tnTo, struct MUI_NListtree_TreeNode *tnFrom)
5733 {
5734 const struct MenuListEntry *fteFrom = (const struct MenuListEntry *) tnFrom->tn_User;
5735 const struct MenuListEntry *fteTo = (const struct MenuListEntry *) tnTo->tn_User;
5736 BOOL MayPaste = FALSE;
5737
5738 d1(kprintf("%s/%ld: fteTo=%08lx <%s> %ld fteFrom=%08lx <%s> %ld\n", __FUNC__, __LINE__, \
5739 fteTo, tnTo->tn_Name, fteTo->llist_EntryType, fteFrom, tnFrom->tn_Name, fteFrom->llist_EntryType));
5740
5741 if (fteTo->llist_EntryType >= ENTRYTYPE_MAX || fteFrom->llist_EntryType >= ENTRYTYPE_MAX)
5742 return FALSE;
5743
5744 d1(kprintf("%s/%ld: MayPaste=%ld\n", __FUNC__, __LINE__, \
5745 MayPasteIntoMatrix[fteTo->llist_EntryType][fteFrom->llist_EntryType]));
5746
5747 if (MayPasteIntoMatrix[fteTo->llist_EntryType][fteFrom->llist_EntryType])
5748 {
5749 MayPaste = TRUE;
5750
5751 if ((SCAMENUTYPE_MainMenu == fteTo->llist_EntryType)
5752 && (SCAMENUTYPE_Menu != fteFrom->llist_EntryType)
5753 && !IsPopupMenu(inst, tnTo))
5754 {
5755 // Only menus may be dropped onto Main menu
5756 MayPaste = FALSE;
5757 }
5758 if ( 0 == strlen(tnTo->tn_Name) )
5759 {
5760 // Nothing may be dropped onto a separator
5761 MayPaste = FALSE;
5762 }
5763 }
5764
5765 return MayPaste;
5766 }
5767
5768 //----------------------------------------------------------------------------
5769
5770 static struct MUI_NListtree_TreeNode *MayPasteBelow(struct MenuPrefsInst *inst,
5771 struct MUI_NListtree_TreeNode *tnTo, struct MUI_NListtree_TreeNode *tnFrom)
5772 {
5773 const struct MenuListEntry *fteFrom = (const struct MenuListEntry *) tnFrom->tn_User;
5774 const struct MenuListEntry *fteTo = (const struct MenuListEntry *) tnTo->tn_User;
5775 struct MUI_NListtree_TreeNode *tn;
5776 BOOL Result = FALSE;
5777
5778 d1(KPrintF("%s/%ld: START fteTo=%08lx <%s> %ld fteFrom=%08lx <%s> %ld\n", __FUNC__, __LINE__, \
5779 fteTo, tnTo->tn_Name, fteTo->llist_EntryType, fteFrom, tnFrom->tn_Name, fteFrom->llist_EntryType));
5780
5781 do {
5782 if (fteTo->llist_EntryType >= ENTRYTYPE_MAX || fteFrom->llist_EntryType >= ENTRYTYPE_MAX)
5783 break;
5784
5785 if (tnTo->tn_Flags & TNF_OPEN)
5786 {
5787 tn = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
5788 MUIM_NListtree_GetEntry,
5789 tnTo,
5790 MUIV_NListtree_GetEntry_Position_Head,
5791 MUIV_NListtree_GetEntry_Flag_Visible);
5792 d1(KPrintF("%s/%ld: tn=%08lx\n", __FUNC__, __LINE__, tn));
5793
5794 if (tn)
5795 break;
5796 }
5797
5798 do {
5799 tn = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
5800 MUIM_NListtree_GetEntry,
5801 tnTo,
5802 MUIV_NListtree_GetEntry_Position_Next,
5803 MUIV_NListtree_GetEntry_Flag_SameLevel | MUIV_NListtree_GetEntry_Flag_Visible);
5804 d1(KPrintF("%s/%ld: tn=%08lx\n", __FUNC__, __LINE__, tn));
5805 if (tn)
5806 break;
5807
5808 tnTo = (struct MUI_NListtree_TreeNode *) DoMethod(inst->mpb_Objects[OBJNDX_MainListTree],
5809 MUIM_NListtree_GetEntry,
5810 tnTo,
5811 MUIV_NListtree_GetEntry_Position_Parent,
5812 MUIV_NListtree_GetEntry_Flag_Visible);
5813 d1(KPrintF("%s/%ld: tnTo=%08lx\n", __FUNC__, __LINE__, tnTo));
5814
5815 if (tnTo)
5816 {
5817 fteTo = (const struct MenuListEntry *) tnTo->tn_User;
5818
5819 Result = MayPasteAfterMatrix[fteTo->llist_EntryType][fteFrom->llist_EntryType];
5820 }
5821 } while (tnTo && !Result);
5822
5823 if (NULL == tnTo)
5824 break;
5825
5826 Result = MayPasteAfterMatrix[fteTo->llist_EntryType][fteFrom->llist_EntryType];
5827 } while (0);
5828
5829 d1(KPrintF("%s/%ld: END MayPaste=%ld\n", __FUNC__, __LINE__, Result));
5830
5831 return Result ? tnTo : NULL;
5832 }
5833
5834 //----------------------------------------------------------------------------
5835
5836 #ifdef __amigaos4__
5837
5838 static char *stpblk(const char *q)
5839 {
5840 while (q && *q && isspace((int) *q))
5841 q++;
5842
5843 return (char *) q;
5844 }
5845
5846 #elif !defined(__SASC) && !defined(__AROS__)
5847 // Replacement for SAS/C library functions
5848
5849 #if !defined(__MORPHOS__)
5850
5851 static char *stpblk(const char *q)
5852 {
5853 while (q && *q && isspace((int) *q))
5854 q++;
5855
5856 return (char *) q;
5857 }
5858
5859 static size_t stccpy(char *dest, const char *src, size_t MaxLen)
5860 {
5861 size_t Count = 0;
5862
5863 while (*src && MaxLen > 1)
5864 {
5865 *dest++ = *src++;
5866 MaxLen--;
5867 Count++;
5868 }
5869 *dest = '\0';
5870 Count++;
5871
5872 return Count;
5873 }
5874 #endif /*__MORPHOS__*/
5875
5876 void exit(int x)
5877 {
5878 (void) x;
5879 while (1)
5880 ;
5881 }
5882
5883 APTR _WBenchMsg;
5884
5885 #endif
5886
Mirror of AROS' Contrib svn.