/*
**	CopyPanel.c
**
**	Editing panel for configuration copying
**
**	Copyright © 1990-1996 by Olaf `Olsen' Barthel
**		All Rights Reserved
*/

#ifndef _GLOBAL_H
#include "Global.h"
#endif

enum	{	GAD_SERIAL=1,GAD_MODEM,GAD_SCREEN,GAD_TERMINAL,GAD_EMULATION,
		GAD_CLIPBOARD,GAD_CAPTURE,GAD_COMMANDS,GAD_MISC,GAD_PATHS,GAD_TRANSFER,
		GAD_TRANSLATION,GAD_KEYMACROS,GAD_CURSORKEYS,GAD_FASTMACROS,GAD_COPYTOALL,
		GAD_DEFAULT,GAD_ALL,GAD_CLEAR,GAD_USE,GAD_CANCEL };

enum	{	COPY_MAIN_CONFIG,COPY_DEFAULTS };

STATIC ULONG	Bits		= 0;

STATIC BYTE	CopyMode	= COPY_MAIN_CONFIG;
STATIC BOOLEAN	AllFileSettings	= FALSE;

STATIC VOID
CopyConfig(struct Configuration *MyConfig,LONG Part)
{
	STATIC LONG TypeMappings[15][2] =
	{
		GAD_SERIAL,		PREF_SERIAL,
		GAD_MODEM,		PREF_MODEM,
		GAD_SCREEN,		PREF_SCREEN,
		GAD_TERMINAL,		PREF_TERMINAL,
		GAD_EMULATION,		PREF_EMULATION,
		GAD_CLIPBOARD,		PREF_CLIP,
		GAD_CAPTURE,		PREF_CAPTURE,
		GAD_COMMANDS,		PREF_COMMAND,
		GAD_MISC,		PREF_MISC,
		GAD_PATHS,		PREF_PATH,
		GAD_TRANSFER,		PREF_TRANSFER,
		GAD_TRANSLATION,	PREF_TRANSLATIONFILENAME,
		GAD_KEYMACROS,		PREF_MACROFILENAME,
		GAD_CURSORKEYS,		PREF_CURSORFILENAME,
		GAD_FASTMACROS,		PREF_FASTMACROFILENAME
	};

	LONG i,PrefType;
	APTR Data;

	for(i = 0 ; i < 15 ; i++)
	{
		if(Part == TypeMappings[i][0])
		{
			PrefType = TypeMappings[i][1];

			break;
		}
	}

	Data = GetConfigEntry(MyConfig,PrefType);

	if(CopyMode == COPY_MAIN_CONFIG)
	{
		if(CreateConfigEntry(MyConfig,PrefType))
		{
			if(!Data)
				ResetConfigEntry(MyConfig,PrefType,FALSE);

			switch(Part)
			{
				case GAD_SERIAL:

					CopyMem(Config -> SerialConfig,MyConfig -> SerialConfig,sizeof(struct SerialSettings));
					break;

				case GAD_MODEM:

					CopyMem(Config -> ModemConfig,MyConfig -> ModemConfig,sizeof(struct ModemSettings));
					break;

				case GAD_SCREEN:

					CopyMem(Config -> ScreenConfig,MyConfig -> ScreenConfig,sizeof(struct ScreenSettings));
					break;

				case GAD_TERMINAL:

					CopyMem(Config -> TerminalConfig,MyConfig -> TerminalConfig,sizeof(struct TerminalSettings));
					break;

				case GAD_EMULATION:

					CopyMem(Config -> EmulationConfig,MyConfig -> EmulationConfig,sizeof(struct EmulationSettings));
					break;

				case GAD_CLIPBOARD:

					CopyMem(Config -> ClipConfig,MyConfig -> ClipConfig,sizeof(struct ClipSettings));
					break;

				case GAD_CAPTURE:

					CopyMem(Config -> CaptureConfig,MyConfig -> CaptureConfig,sizeof(struct CaptureSettings));
					break;

				case GAD_COMMANDS:

					CopyMem(Config -> CommandConfig,MyConfig -> CommandConfig,sizeof(struct CommandSettings));
					break;

				case GAD_MISC:

					CopyMem(Config -> MiscConfig,MyConfig -> MiscConfig,sizeof(struct MiscSettings));
					break;

				case GAD_PATHS:

					CopyMem(Config -> PathConfig,MyConfig -> PathConfig,sizeof(struct PathSettings));
					break;

				case GAD_TRANSFER:

					CopyMem(Config -> TransferConfig,MyConfig -> TransferConfig,sizeof(struct TransferSettings));
					break;

				case GAD_TRANSLATION:

					strcpy(MyConfig -> TranslationFileName,Config -> TranslationFileName);
					break;

				case GAD_KEYMACROS:

					strcpy(MyConfig -> MacroFileName,Config -> MacroFileName);
					break;

				case GAD_CURSORKEYS:

					strcpy(MyConfig -> CursorFileName,Config -> CursorFileName);
					break;

				case GAD_FASTMACROS:

					strcpy(MyConfig -> FastMacroFileName,Config -> FastMacroFileName);
					break;
			}
		}
	}
	else
	{
		if(Data && (PrefType != PREF_FILE || AllFileSettings))
			DeleteConfigEntry(MyConfig,PrefType);
	}
}

BOOL
CopyPanel(struct Window *Parent,struct Configuration *MyConfig,BOOL Selective)
{
	BOOL			 MadeChanges = FALSE;
	struct LayoutHandle	*Handle;

	if(Handle = LT_CreateHandleTags(Window -> WScreen,
		LH_LocaleHook,	&LocaleHook,
	TAG_DONE))
	{
		struct Window *PanelWindow;

		LT_New(Handle,
			LA_Type,	VERTICAL_KIND,
		TAG_DONE);
		{
			LT_New(Handle,
				LA_Type,	HORIZONTAL_KIND,
				LA_LabelID,	MSG_V36_0028,
			TAG_DONE);
			{
				LONG i;

				for(i = 0 ; i <= GAD_FASTMACROS - GAD_SERIAL ; i++)
				{
					if(!(i % 5))
					{
						LT_New(Handle,
							LA_Type,	VERTICAL_KIND,
						TAG_DONE);
					}

					LT_New(Handle,
						LA_Type,	CHECKBOX_KIND,
						LA_LabelID,	MSG_COPYPANEL_SERIAL_GAD + i,
						LA_ID,		GAD_SERIAL + i,
						GTCB_Checked,	Bits & (1L << i),
					TAG_DONE);

					if(!((i + 1) % 5))
						LT_EndGroup(Handle);
				}

				LT_EndGroup(Handle);
			}

			LT_New(Handle,
				LA_Type,	VERTICAL_KIND,
			TAG_DONE);
			{
				LT_New(Handle,
					LA_Type,	XBAR_KIND,
				TAG_DONE);

				LT_EndGroup(Handle);
			}

			LT_New(Handle,
				LA_Type,	VERTICAL_KIND,
			TAG_DONE);
			{
				LT_New(Handle,
					LA_Type,	CHECKBOX_KIND,
					LA_LabelID,	MSG_COPYPANEL_TO_ALL_ENTRIES_GAD,
					LA_ID,		GAD_COPYTOALL,
					GTCB_Checked,	!MyConfig,
					GA_Disabled,	!MyConfig,
				TAG_DONE);

				LT_New(Handle,
					LA_Type,	MX_KIND,
					LA_LabelID,	MSG_COPYPANEL_COPY_TYPE_GAD,
					LA_ID,		GAD_DEFAULT,
					LA_BYTE,	&CopyMode,
					LAMX_FirstLabel,MSG_COPYPANEL_COPY_GLOBAL_CONFIG_MSG,
					LAMX_LastLabel,	MSG_COPYPANEL_COPY_GLOBAL_DEFAULTS_MSG,
				TAG_DONE);

				LT_EndGroup(Handle);
			}

			LT_New(Handle,
				LA_Type,	VERTICAL_KIND,
			TAG_DONE);
			{
				LT_New(Handle,
					LA_Type,	XBAR_KIND,
				TAG_DONE);

				LT_EndGroup(Handle);
			}

			LT_New(Handle,
				LA_Type,	HORIZONTAL_KIND,
			TAG_DONE);
			{
				LT_New(Handle,
					LA_Type,	BUTTON_KIND,
					LA_LabelID,	MSG_COPYPANEL_ALL_GAD,
					LA_ID,		GAD_ALL,
				TAG_DONE);

				LT_New(Handle,
					LA_Type,	BUTTON_KIND,
					LA_LabelID,	MSG_COPYPANEL_CLEAR_GAD,
					LA_ID,		GAD_CLEAR,
				TAG_DONE);

				LT_EndGroup(Handle);
			}

			LT_New(Handle,
				LA_Type,	VERTICAL_KIND,
			TAG_DONE);
			{
				LT_New(Handle,LA_Type,XBAR_KIND,LAXB_FullSize,TRUE,TAG_DONE);

				LT_EndGroup(Handle);
			}

			LT_New(Handle,LA_Type,HORIZONTAL_KIND,
				LAGR_SameSize,	TRUE,
				LAGR_Spread,	TRUE,
			TAG_DONE);
			{
				LT_New(Handle,
					LA_Type,	BUTTON_KIND,
					LA_LabelID,	MSG_GLOBAL_USE_GAD,
					LA_ID,		GAD_USE,
					LABT_ReturnKey,	TRUE,
					LABT_ExtraFat,	TRUE,
				TAG_DONE);

				LT_New(Handle,
					LA_Type,	BUTTON_KIND,
					LA_LabelID,	MSG_GLOBAL_CANCEL_GAD,
					LA_ID,		GAD_CANCEL,
					LABT_EscKey,	TRUE,
					LABT_ExtraFat,	TRUE,
				TAG_DONE);

				LT_EndGroup(Handle);
			}

			LT_EndGroup(Handle);
		}

		if(PanelWindow = LT_Build(Handle,
			LAWN_TitleID,		MSG_COPYPANEL_COPY_CONFIG_TXT,
			LAWN_IDCMP,		IDCMP_CLOSEWINDOW,
			LAWN_HelpHook,		&GuideHook,
			LAWN_Parent,		Parent,
			WA_DepthGadget,		TRUE,
			WA_CloseGadget,		TRUE,
			WA_DragBar,		TRUE,
			WA_RMBTrap,		TRUE,
			WA_Activate,		TRUE,
			WA_SimpleRefresh,	TRUE,
		TAG_DONE))
		{
			struct IntuiMessage	*Message;
			BOOL			 Done = FALSE;
			ULONG			 MsgClass;
			struct Gadget		*MsgGadget;

			GuideContext(CONTEXT_COPY);

			PushWindow(PanelWindow);

			LT_ShowWindow(Handle,TRUE);

			do
			{
				if(Wait(PORTMASK(PanelWindow -> UserPort) | SIG_BREAK) & SIG_BREAK)
					break;

				while(Message = (struct IntuiMessage *)LT_GetIMsg(Handle))
				{
					MsgClass	= Message -> Class;
					MsgGadget	= (struct Gadget *)Message -> IAddress;

					LT_ReplyIMsg(Message);

					if(MsgClass == IDCMP_CLOSEWINDOW)
						Done = TRUE;

					if(MsgClass == IDCMP_GADGETUP)
					{
						LONG i;

						switch(MsgGadget -> GadgetID)
						{
							case GAD_ALL:

								for(i = GAD_SERIAL ; i <= GAD_FASTMACROS ; i++)
									LT_SetAttributes(Handle,i,GTCB_Checked,TRUE,TAG_DONE);

								break;

							case GAD_CLEAR:

								for(i = GAD_SERIAL ; i <= GAD_FASTMACROS ; i++)
									LT_SetAttributes(Handle,i,GTCB_Checked,FALSE,TAG_DONE);

								break;

							case GAD_USE:

								Bits = NULL;

								if(LT_GetAttributes(Handle,GAD_COPYTOALL,TAG_DONE))
								{
									LONG j;

									AllFileSettings = TRUE;

									for(i = GAD_TRANSLATION ; i <= GAD_FASTMACROS ; i++)
										AllFileSettings &= LT_GetAttributes(Handle,i,TAG_DONE);

									if(Selective)
									{
										for(i = 0 ; i <= GAD_FASTMACROS - GAD_SERIAL ; i++)
										{
											if(LT_GetAttributes(Handle,GAD_SERIAL + i,TAG_DONE))
											{
												for(j = 0 ; j < NumPhoneEntries ; j++)
												{
													if(Phonebook[j] -> Count != -1)
														CopyConfig(Phonebook[j] -> Config,GAD_SERIAL + i);
												}

												Bits |= (1L << i);

												MadeChanges = TRUE;
											}
										}
									}
									else
									{
										for(i = 0 ; i <= GAD_FASTMACROS - GAD_SERIAL ; i++)
										{
											if(LT_GetAttributes(Handle,GAD_SERIAL + i,TAG_DONE))
											{
												for(j = 0 ; j < NumPhoneEntries ; j++)
													CopyConfig(Phonebook[j] -> Config,GAD_SERIAL + i);

												Bits |= (1L << i);

												MadeChanges = TRUE;
											}
										}
									}
								}
								else
								{
									if(MyConfig)
									{
										for(i = 0 ; i <= GAD_FASTMACROS - GAD_SERIAL ; i++)
										{
											if(LT_GetAttributes(Handle,GAD_SERIAL + i,TAG_DONE))
											{
												CopyConfig(MyConfig,GAD_SERIAL + i);

												Bits |= (1L << i);

												MadeChanges = TRUE;
											}
										}
									}
								}

								Done = TRUE;
								break;

							case GAD_CANCEL:

								Done = TRUE;
								break;
						}
					}
				}
			}
			while(!Done);

			PopWindow();
		}

		LT_DeleteHandle(Handle);
	}

	return(MadeChanges);
}