コード例 #1
0
// Update checkmarks in action list
void filetypeed_update_actions(filetype_ed_data *data)
{
	Att_Node *node;

	// Detach list from listview
	SetGadgetChoices(data->objlist,GAD_FILETYPEED_ACTION_LIST,(APTR)~0);

	// Go through action list
	for (node=(Att_Node *)data->action_list->list.lh_Head;
		node->node.ln_Succ;
		node=(Att_Node *)node->node.ln_Succ)
	{
		Cfg_Function *func;

		// Initially not selected
		node->node.lve_Flags&=~LVEF_SELECTED;

		// Go through function list
		for (func=(Cfg_Function *)data->type->function_list.lh_Head;
			func->node.ln_Succ;
			func=(Cfg_Function *)func->node.ln_Succ)
		{
			// Right type?
			if (func->function.func_type==node->data &&
				!(func->function.flags2&FUNCF2_LABEL_FUNC))
			{
				node->node.lve_Flags|=LVEF_SELECTED;
				break;
			}
		}
	}

	// Reattach list
	SetGadgetChoices(data->objlist,GAD_FILETYPEED_ACTION_LIST,data->action_list);
}
コード例 #2
0
void config_env_store_sound(config_env_data *data)
{
	short num;
	Cfg_SoundEntry *sound;

	// Get selection
	if ((num=GetGadgetValue(data->option_list,GAD_SETTINGS_SOUNDLIST))>-1 &&
		(sound=(Cfg_SoundEntry *)Att_FindNode((Att_List *)&data->sound_list,num)))
	{
		short flags,old_volume;
		char old_sound[256];
		
		strcpy(old_sound,sound->dse_Sound);
		old_volume=sound->dse_Volume;

		strcpy(sound->dse_Sound,(char *)GetGadgetValue(data->option_list,GAD_SETTINGS_SOUNDLIST_PATH));
		UpdateGadgetValue(data->option_list,0,GAD_SETTINGS_VOLUME);
		if ((sound->dse_Volume=GetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME))<0)
			sound->dse_Volume=0;
		else
		if (sound->dse_Volume>64)
			sound->dse_Volume=64;
		SetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME,sound->dse_Volume);
		SetGadgetValue(data->option_list,GAD_SETTINGS_VOLUME_SLIDER,sound->dse_Volume);

		// Did sound change?
		if (strcmp(old_sound,sound->dse_Sound)!=0)
		{
			// Fix pen usage
			flags=sound->dse_Node.lve_Flags;
			if (sound->dse_Sound[0])
				sound->dse_Node.lve_Flags|=LVEF_USE_PEN;
			else
				sound->dse_Node.lve_Flags&=~LVEF_USE_PEN;
			if (flags!=sound->dse_Node.lve_Flags)
			{
				SetGadgetChoices(data->objlist,GAD_SETTINGS_SOUNDLIST,(APTR)~0);
				SetGadgetChoices(data->objlist,GAD_SETTINGS_SOUNDLIST,&data->sound_list);
			}
			sound->dse_Node.lve_Flags|=LVEF_TEMP;
		}

		// Or volume?
		else
		if (old_volume!=sound->dse_Volume)
			sound->dse_Node.lve_Flags|=LVEF_TEMP;
	}
}
コード例 #3
0
// Open window
BOOL config_paths_open(config_path_data *data,struct Screen *screen)
{
	// Already open?
	if (data->window) return 1;

	// Fill out and open window
	data->newwin.parent=screen;
	data->newwin.dims=&pathformat_window;
	data->newwin.title=GetString(locale,MSG_PATHFORMAT_TITLE);
	data->newwin.locale=locale;
	data->newwin.flags=WINDOW_VISITOR|WINDOW_AUTO_KEYS|WINDOW_REQ_FILL|WINDOW_SCREEN_PARENT;
	if (!(data->window=OpenConfigWindow(&data->newwin)) ||
		!(data->objlist=AddObjectList(data->window,pathformat_objects)))
	{
		config_paths_cleanup(data);
		return 0;
	}

	// Add AppWindow
	if (data->appport)
		data->appwindow=AddAppWindowA(0,0,data->window,data->appport,0);

	// Attach path list
	SetGadgetChoices(data->objlist,GAD_PATHFORMAT_PATHS,data->path_list);

	// Initially disable everything
	config_paths_disable(data,TRUE);
	return 1;
}
コード例 #4
0
// Receive an edited filetype
BOOL filetype_receive_edit(
	config_filetypes_data *data,
	Cfg_Filetype *type,
	FiletypeNode *node)
{
	BOOL success=0;
	Cfg_Filetype *type_copy;
	Att_Node *display_node;

	// Try to copy the new filetype
	if ((type_copy=CopyFiletype(type,data->memory)))
	{
		// Get list pointer from existing filetype
		type_copy->list=node->type->list;
		type_copy->list->flags|=FTLISTF_CHANGED;

		// Free existing filetype
		FreeFiletype(node->type);

		// Add new filetype to list
		AddTail(&type_copy->list->filetype_list,&type_copy->node);

		// Remove existing display list
		SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,(APTR)~0);

		// Free display node
		if ((display_node=Att_FindNodeData(data->filetype_list,(ULONG)node)))
			Att_RemNode(display_node);
		FreeVec(node);

		// Add new filetype entry
		filetype_add_entry(data,type_copy);

		// Reattach list to gadget
		SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,data->filetype_list);

		// Set success flag
		success=1;
	}

	return success;
}
コード例 #5
0
// Update flag selections
void funced_update_flaglist(FuncEdData *data)
{
	Att_Node *node;

	// Detach existing list
	SetGadgetChoices(data->objlist,GAD_FUNCED_FLAGS,(APTR)~0);

	// Go through flag list
	for (node=(Att_Node *)data->flag_list->list.lh_Head;
		node->node.ln_Succ;
		node=(Att_Node *)node->node.ln_Succ)
	{
		// Is flag set?
		if (data->function->function.flags&node->data) node->node.lve_Flags|=LVEF_SELECTED;
		else node->node.lve_Flags&=~LVEF_SELECTED;
	}

	// Attach list to gadget
	SetGadgetChoices(data->objlist,GAD_FUNCED_FLAGS,data->flag_list);
}
コード例 #6
0
// Build list of available filetypes
void filetype_build_list(config_filetypes_data *data)
{
	Cfg_FiletypeList *list;
	Cfg_Filetype *type;

	// Remove existing list
	SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,(APTR)~0);

	// Free list
	Att_RemList(data->filetype_list,REMLIST_FREEDATA);

	// Create new list
	if ((data->filetype_list=Att_NewList(0)))
	{
		// Go through filetype lists
		for (list=(Cfg_FiletypeList *)data->list_list.lh_Head;
			list->node.ln_Succ;
			list=(Cfg_FiletypeList *)list->node.ln_Succ)
		{
			// Go through filetypes in this list
			for (type=(Cfg_Filetype *)list->filetype_list.lh_Head;
				type->node.ln_Succ;
				type=(Cfg_Filetype *)type->node.ln_Succ)
			{
				// Add an entry for this filetype
				filetype_add_entry(data,type);
			}
		}
	}

	// Add list to gadget
	SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,data->filetype_list);

	// Clear current selection
	SetGadgetValue(data->objlist,GAD_FILETYPES_LIST,(ULONG)-1);
	data->sel_filetype=0;

	// Disable buttons
	filetype_able_buttons(data,TRUE);
}
コード例 #7
0
// Build display list from function list
void funced_build_display(FuncEdData *data)
{
	Att_Node *node;

	// Detach existing list
	SetGadgetChoices(data->objlist,GAD_FUNCED_LISTER,(APTR)~0);

	// Clear list
	Att_RemList(data->func_display_list,REMLIST_SAVELIST);

	// Go through function list
	for (node=(Att_Node *)data->function_list->list.lh_Head;
		node->node.ln_Succ;
		node=(Att_Node *)node->node.ln_Succ)
	{
		// Build display string for this node
		funced_build_entrydisplay(data,0,(FunctionEntry *)node->data);
	}

	// Attach list to gadget
	SetGadgetChoices(data->objlist,GAD_FUNCED_LISTER,data->func_display_list);
}
コード例 #8
0
// Add an entry
void config_paths_add(config_path_data *data,BOOL activate)
{
	position_rec *pos;
	Att_Node *node;

	// Create a new entry
	if ((pos=(position_rec *)AllocMemH(data->memory,sizeof(position_rec)+256)))
	{
		// Initialise entry
		pos->node.ln_Type=PTYPE_POSITION;
		pos->node.ln_Name=pos->name;
		pos->flags|=POSITIONF_USER|POSITIONF_NEW;
		if (data->def_format)
			CopyMem((char *)data->def_format,(char *)&pos->format,sizeof(ListFormatStorage));

		// Initialise key
		pos->code=0xffff;

		// Add to list path list
		AddTail(data->paths,(struct Node *)pos);

		// Remove list from gadget
		SetGadgetChoices(data->objlist,GAD_PATHFORMAT_PATHS,(APTR)~0);

		// Add to lister
		node=Att_NewNode(data->path_list,0,(ULONG)pos,ADDNODE_SORT);

		// Attach list to gadget
		SetGadgetChoices(data->objlist,GAD_PATHFORMAT_PATHS,data->path_list);

		// Select the new node
		config_paths_select(data,node,TRUE);

		// Activate path field
		if (activate) ActivateStrGad(GADGET(GetObject(data->objlist,GAD_PATHFORMAT_PATH)),data->window);
	}
}
コード例 #9
0
// Handle new nodes
void filetype_new_node(config_filetypes_data *data,Att_Node *node)
{
	// Reattach list
	SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,data->filetype_list);

	// Select the new entry
	data->sel_filetype=node;
	SetGadgetValue(data->objlist,GAD_FILETYPES_LIST,Att_FindNodeNumber(data->filetype_list,node));

	// Enable buttons
	filetype_able_buttons(data,FALSE);

	// Launch editor for this filetype
	if (node)
	{
		filetype_edit(data,(FiletypeNode *)node->data,1);
		data->change=1;
	}
}
コード例 #10
0
ファイル: font.c プロジェクト: timofonic/dopus5allamigas
// Build size labels
void font_build_labels(font_data *data,struct FontContentsHeader *fch)
{
	char **labels,*ptr;
	short num=0,a,smallest=0;
	struct FontContents *fc=NULL;
	BOOL topaz=FALSE;

	// Get number
	if (fch) num=fch->fch_NumEntries;
	if (num<1)
	{
		num=1;
		fch=NULL;
	}

	// Kludge for topaz
	if (fch)
	{
		// Get first contents pointer
		fc=(struct FontContents *)(fch+1);

		// Topaz?
		if (strnicmp(fc->fc_FileName,"topaz/",6)==0)
		{
			// Add 8 and 9
			num+=2;
			topaz=TRUE;
		}
	}

	// Allocate array and buffer
	if (!(ptr=AllocVec((sizeof(char *)+8)*(num+1),MEMF_CLEAR)))
		return;

	// Get label array, bump pointer
	labels=(char **)ptr;
	ptr+=sizeof(char *)*(num+1);

	// No font contents?
	if (!fc)
	{
		// Null label
		labels[0]=ptr;
		labels[1]=0;
	}

	// Get label pointers, build labels
	else
	for (a=0;a<num;a++,ptr+=8)
	{
		// Get pointer
		labels[a]=ptr;

		// Topaz kludge?
		if (topaz && a<2)
		{
			short val=8+a;

			// Add 8 or 9
			labels[a][0]='0'+val;
			labels[a][1]=0;

			// Is this the smallest?
			if (!smallest || val<smallest)
				smallest=val;
		}

		// Normal font
		else
		{
			// Add size
			lsprintf(labels[a],"%ld",fc->fc_YSize);

			// Is this the smallest?
			if (!smallest || fc->fc_YSize<smallest)
				smallest=fc->fc_YSize;

			// Bump contents pointer
			fc++;
		}
	}

	// Use smallest as first size to show
	if (!data->first && smallest) data->font_size=smallest;

	// Use new labels
	SetGadgetChoices(data->list,GAD_FONT_CYCLE,labels);

	// Disable if no labels
	DisableObject(data->list,GAD_FONT_CYCLE,(BOOL)!labels[1]);

	// Free old labels, store pointer
	FreeVec(data->size_labels);
	data->size_labels=labels;
}
コード例 #11
0
ファイル: register.c プロジェクト: MrZammler/opus_magellan
Att_List *build_text_display(struct Window *window,ObjectList *objlist,char *text)
{
	Att_List *list;
	struct TextExtent extent;
	short want_len,max_len,textlen=0,width;
	char *textpos=0;
	struct Rectangle rect;
	char old;

	// Allocate a new list
	list=Att_NewList(0);

	// Get list object size
	GetObjectRect(objlist,GAD_TEXT_DISPLAY,&rect);
	width=RECTWIDTH(&rect)-28;

	// Go through text
	FOREVER
	{
		// No current line?
		if (!textpos) textpos=text;

		// Move on from current line
		else
		{
			// Were we on a newline?
			if (textlen==0) ++textpos;

			// No
			else
			{
				// Bump pointer
				textpos+=textlen;

				// If this leaves us on a newline or space, skip over it
				if (*textpos=='\n' || *textpos=='\t') ++textpos;
			}
		}

		// End of text?
		if (!*textpos) break;

		// If we're on a space, skip over it
		if (*textpos==' ') ++textpos;

		// Calculate desired length of the line
		for (want_len=0;textpos[want_len] && textpos[want_len]!='\n';++want_len);

		// Blank line?
		if (want_len==0)
		{
			textlen=0;
		}

		// Not blank
		else
		{
			// Get maximum length that will actually fit
			max_len=TextFit(
				window->RPort,
				textpos,
				want_len,
				&extent,
				0,1,
				width,window->RPort->TxHeight);

			// Go from here to end of current word
			want_len=max_len;
			while ( textpos[want_len] &&
					textpos[want_len]!='\n' && 
					textpos[want_len]!=' ') ++want_len;

			// Loop until successful
			do
			{
				// Get text size
				TextExtent(window->RPort,textpos,want_len,&extent);

				// Will it fit?
				if (extent.te_Width<=width)
				{
					// Save size
					textlen=want_len;
					break;
				}

				// Come backwards to word break
				for (--want_len;want_len>0 && textpos[want_len]!=' ';--want_len);

				// Didn't find one?
				if (want_len<1)
				{
					// Get maximum length
					want_len=max_len;
				}
			} while(1);
		}

		// Null out break temporarily
		old=textpos[textlen];
		textpos[textlen]=0;

		// Add node
		Att_NewNode(list,textpos,0,0);

		// Restore character
		textpos[textlen]=old;
	}

	// Add list to display
	SetGadgetChoices(objlist,GAD_TEXT_DISPLAY,list);
	return list;
}
コード例 #12
0
// Change entry's path
void config_paths_change(config_path_data *data)
{
	char *str;
	BPTR lock;
	char path[256];
	position_rec *pos;
	Att_Node *node;
	struct List *search;

	// No path selected?
	if (!data->path_sel) return;

	// Get path string
	str=(char *)GetGadgetValue(data->objlist,GAD_PATHFORMAT_PATH);

	// Invalid?
	if (!str || !*str)
	{
		// Remove this path
		config_paths_remove(data,TRUE);
		return;
	}

	// Try to lock
	if ((lock=Lock(str,ACCESS_READ)))
	{
		// Get full pathname
		NameFromLock(lock,path,256);
		UnLock(lock);
	}

	// Otherwise, use entered path
	else strcpy(path,str);

	// Fix path with trailing /
	AddPart(path,"",256);

	// See if path is already in edit list
	if ((node=(Att_Node *)FindNameI((struct List *)data->path_list,path)))
	{
		// Not the currently selected node?
		if (node!=data->path_sel)
		{
			// Error
			DisplayBeep(data->window->WScreen);
			ActivateStrGad(GADGET(GetObject(data->objlist,GAD_PATHFORMAT_PATH)),data->window);
			return;
		}
	}

	// Is path already in snapshot list?
	search=data->paths;
	while ((pos=(position_rec *)FindNameI(search,path)))
	{
		// Position entry?
		if (pos->node.ln_Type==PTYPE_POSITION) break;
		search=(struct List *)pos;
	}

	// Found it?
	if (pos)
	{
		// Different entry?
		if (pos!=(position_rec *)data->path_sel->data)
		{
			// Remove current entry from list
			Remove((struct Node *)data->path_sel->data);

			// Free current data
			FreeMemH((void *)data->path_sel->data);
			data->path_sel->data=(ULONG)pos;
		}

		// If path exists, clear "new" flag
		if (lock) pos->flags&=~POSITIONF_NEW;
	}

	// It is now
	else pos=(position_rec *)data->path_sel->data;

	// Set its user flag
	pos->flags|=POSITIONF_USER;

	// Store new name
	strcpy(pos->name,path);

	// Remove list from gadget
	SetGadgetChoices(data->objlist,GAD_PATHFORMAT_PATHS,(APTR)~0);

	// Remove existing node and add new one
	Att_RemNode(data->path_sel);

	// Add to list
	data->path_sel=Att_NewNode(data->path_list,pos->node.ln_Name,(ULONG)pos,ADDNODE_SORT);

	// Attach list to gadget
	SetGadgetChoices(data->objlist,GAD_PATHFORMAT_PATHS,data->path_list);

	// Select the new node
	config_paths_select(data,data->path_sel,TRUE);
}
コード例 #13
0
void FunctionEditor(void)
{
	struct IntuiMessage *gmsg,msg;
	int break_flag=0;
	UWORD gadgetid=0;
	ULONG waitbits;
	FuncEdData *data;
	IPCData *ipc;
	NewConfigWindow newwin;
	FunctionStartup *startup=0;
	IPCMessage *submsg;
	int success=0;
	BOOL open_window=1;
	BPTR lock;
	ConfigWindow windims;

	// Do startup
	if (!(ipc=Local_IPC_ProcStartup((ULONG *)&startup, (APTR)&funced_init)))
	{
		funced_cleanup(startup->data);
		return;
	}

	// Get data pointer
	data=startup->data;

	// Lock RAM: and CD to it
	if ((lock=Lock("ram:",ACCESS_READ)))
		lock=CurrentDir(lock);

	// Copy dimensions
	if (startup->flags&FUNCEDF_CENTER)
		windims=_function_editor_window_center;
	else
	if (startup->flags&FUNCEDF_LABEL)
		windims=_function_editor_label_window;
	else
		windims=_function_editor_window;

	// Fill in new window
	newwin.parent=startup->window;
	newwin.dims=&windims;
	newwin.title=(startup->title[0])?startup->title:(char *)GetString(startup->locale,MSG_FUNCED_TITLE);
	newwin.locale=startup->locale;
	newwin.port=0;
	newwin.flags=WINDOW_VISITOR|WINDOW_AUTO_KEYS|WINDOW_REQ_FILL;//|WINDOW_SIZE_BOTTOM;
	newwin.font=0;

	// Build flag list
	funced_build_flaglist(data);
	waitbits=1<<ipc->command_port->mp_SigBit|1<<data->drag.timer->port->mp_SigBit;

	// Event loop
	FOREVER
	{
		// Check drag
		if (config_drag_check(&data->drag))
		{
			// End drag
			functioned_end_drag(data,0);
		}

		// Task message?
		while ((submsg=(IPCMessage *)GetMsg(ipc->command_port)))
		{
			// Close message?
			if (submsg->command==IPC_QUIT)
			{
				// Keep changes?
				success=submsg->flags;

				// Set break flag
				break_flag=1;
			}

			// Activate
			else
			if (submsg->command==IPC_ACTIVATE && data->window)
			{
				WindowToFront(data->window);
				ActivateWindow(data->window);
			}

			// Hide
			else
			if (submsg->command==IPC_HIDE && data->window)
			{
				// Store changes in function
				funced_store_edits(data);

				// End any drag in progress
				functioned_end_drag(data,0);

				// Remove AppWindow
				RemoveAppWindow(data->appwindow);
				data->appwindow=0;

				// Close window
				CloseConfigWindow(data->window);

				// Zero stuff
				data->window=0;
				data->objlist=0;
				waitbits=1<<ipc->command_port->mp_SigBit;
			}

			// Show
			else
			if (submsg->command==IPC_SHOW && !data->window)
			{
				// Set flag to open window
				open_window=1;
				newwin.parent=(struct Window *)submsg->data;
			}

			// Passed-along app message
			else
			if (submsg->command==CFG_APPMESSAGE_PASS)
			{
				funced_appmsg(data,submsg->data);
				ReplyMsg((struct Message *)submsg->data);
			}

			// Update our identity
			else
			if (submsg->command==CFG_NEW_ID)
			{
				data->function->function.func_type=submsg->flags;
				startup->object_flags=(ULONG)submsg->data;
			}

			// Copy a function
			else
			if (submsg->command==FUNCTIONEDIT_COPY_LINE)
			{
				FunctionEntry *entry,*next;

				// Copy function
				functioned_copy_line(
					data,
					(FunctionEntry *)submsg->data,
					0,
					(Point *)submsg->data_free);

				// Free function
				entry=(FunctionEntry *)submsg->data;
				while (entry)
				{
					// Get next
					next=(FunctionEntry *)entry->node;

					// Free entry
					FreeVec(entry);
					entry=next;
				}
			}

			// Clip button
			else
			if (submsg->command==BUTTONEDIT_CLIP_BUTTON)
			{
				Cfg_ButtonFunction *func;

				// Show busy pointer
				SetWindowBusy(data->window);

				// Stop editing
				funced_end_edit(data,data->edit_node,0,0);
				data->edit_node=0;

				// Get first function
				if ((func=(Cfg_ButtonFunction *)
					FindFunctionType(
						(struct List *)&((Cfg_Button *)submsg->data)->function_list,
						FTYPE_LEFT_BUTTON)))
				{
					FunctionEntry dummy;
					Cfg_Instruction *ins;

					// Go through instructions
					for (ins=(Cfg_Instruction *)func->instructions.mlh_Head;
						ins->node.mln_Succ;
						ins=(Cfg_Instruction *)ins->node.mln_Succ)
					{
						// Fill out dummy entry
						dummy.type=ins->type;
						if (ins->string) strcpy(dummy.buffer,ins->string);
						else dummy.buffer[0]=0;

						// Copy function line
						data->edit_node=funced_new_entry(data,0,&dummy);
					}

					// Start editing last line
					funced_start_edit(data);

					// Get flags
					data->function->function.flags=func->function.flags;
					data->function->function.code=func->function.code;
					data->function->function.qual=func->function.qual;
					data->function->function.qual_mask=func->function.qual_mask;
					data->function->function.qual_same=func->function.qual_same;

					// Update flag list
					funced_update_flaglist(data);

					// Update key
					funced_show_key(data);
				}

				// Free button
				FreeButton((Cfg_Button *)submsg->data);

				// Clear busy pointer
				ClearWindowBusy(data->window);
			}

			// Reply the message
			IPC_Reply(submsg);
		}

		// Open window?
		if (open_window)
		{
			// Open window
			if (!(data->window=OpenConfigWindow(&newwin)) ||
				!(data->p_objlist=AddObjectList(
					data->window,
					(startup->flags&FUNCEDF_IMAGE)?_function_editor_image_objects:
						((startup->flags&FUNCEDF_LABEL)?_function_editor_label_objects:
														_function_editor_normal_objects))) ||
				!(data->objlist=AddObjectList(data->window,_function_editor_objects)))
				break;

			// Add use or save button
			AddObjectList(data->window,(startup->flags&FUNCEDF_SAVE)?_function_editor_objects_save:_function_editor_objects_use);

			// Store window for drag
			data->drag.window=data->window;

			// Set window ID
			SetWindowID(data->window,0,WINDOW_FUNCTION_EDITOR,(struct MsgPort *)ipc);

			// Add menus
			AddWindowMenus(data->window,_funced_menus);

			// Make this an AppWindow
			data->appwindow=AddAppWindowA(0,0,data->window,data->appport,0);

			// Get waitbits
			waitbits|=1<<data->window->UserPort->mp_SigBit;
			if (data->appwindow) waitbits|=1<<data->appport->mp_SigBit;

			// Disable key?
			if (startup->flags&FUNCEDF_NO_KEY)
			{
				DisableObject(data->objlist,GAD_FUNCED_KEY,TRUE);
			}

			// Initialise gadgets with function data.
			funced_init_gads(data);
			open_window=0;
		}

		// Intuimessage
		if (data->window)
		{
			while ((gmsg=GetWindowMsg(data->window->UserPort)))
			{
				Att_Node *node;

				// Copy message and reply (unless IDCMPUPDATE)
				msg=*gmsg;
				if (gmsg->Class!=IDCMP_IDCMPUPDATE)
				{
					ReplyWindowMsg(gmsg);
					gmsg=0;
				}

				// Get GadgetID
				if (msg.Class==IDCMP_GADGETDOWN ||
					msg.Class==IDCMP_GADGETUP)
					gadgetid=((struct Gadget *)msg.IAddress)->GadgetID;

				// Look at message
				switch (msg.Class)
				{
					// Key press
					case IDCMP_VANILLAKEY:

						// If editing something, activate string gadget
						if (data->edit_node)
							ActivateStrGad(GADGET(GetObject(data->objlist,GAD_FUNCED_EDIT)),data->window);
						break;


					// Close window
					case IDCMP_CLOSEWINDOW:

						// Set break flag
						break_flag=1;
						break;


					// Mouse move
					case IDCMP_MOUSEMOVE:

						// Handle drag move
						config_drag_move(&data->drag);
						break;


					// Inactive window does menu down
					case IDCMP_INACTIVEWINDOW:
						msg.Code=MENUDOWN;

					// Mouse buttons
					case IDCMP_MOUSEBUTTONS:

						// Valid drag info?
						if (data->drag.drag)
						{
							short ok=-1;

							// Dropped ok?
							if (msg.Code==SELECTUP)
							{
								// Is shift down?
								if (msg.Qualifier&(IEQUALIFIER_LSHIFT|IEQUALIFIER_RSHIFT))
									data->drag_shift=1;
								else data->drag_shift=0;

								// Remember last position
								data->drag.drag_x=data->window->WScreen->MouseX;
								data->drag.drag_y=data->window->WScreen->MouseY;
								ok=1;
							}

							// Aborted
							else
							if (msg.Code==MENUDOWN)
							{
								// Set abort
								ok=0;
							}

							// End drag?
							if (ok!=-1) functioned_end_drag(data,ok);
						}
						break;


					// Menu
					case IDCMP_MENUPICK:

						{
							struct MenuItem *item;

							// Get item
							if (!(item=ItemAddress(data->window->MenuStrip,msg.Code)))
								break;

							// Treat as gadget
							gadgetid=MENUID(item);
						}

					// Gadget
					case IDCMP_GADGETUP:
					case IDCMP_GADGETDOWN:

						// Look at gadget ID
						switch (gadgetid)
						{
							// Hotkey
							case GAD_FUNCED_KEY:
								{
									IX ix;
									char *ptr;

									// Get key, see if it's invalid
									if ((ptr=(char *)GetGadgetValue(data->objlist,GAD_FUNCED_KEY)) && *ptr)
									{
										// Try to parse
										if (ParseIX(ptr,&ix))
										{
											// Flash screen
											DisplayBeep(data->window->WScreen);

											// Activate key field again
											ActivateStrGad(GADGET(GetObject(data->objlist,GAD_FUNCED_KEY)),data->window);
										}
										else
										{
											data->function->function.code=ix.ix_Code;
											data->function->function.qual=QualValid(ix.ix_Qualifier);
											data->function->function.qual_mask=ix.ix_QualMask;
											data->function->function.qual_same=ix.ix_QualSame;
										}
									}
								}
								break;


							// Flag selected
							case GAD_FUNCED_FLAGS:

								// Get selected node
								node=Att_FindNode(data->flag_list,msg.Code);

								// Set flag
								data->function->function.flags^=node->data;

								// Check change
								funced_check_flag(&data->function->function.flags,node->data);

								// Update flag list
								funced_update_flaglist(data);
								break;


							// Edit a line
							case GAD_FUNCED_LISTER:

								// Get selected node
								node=Att_FindNode(data->func_display_list,msg.Code);

								// Is this the node we're already editing?
								if (node==data->edit_node) break;

								// If we're editing another one, store its contents
								if (data->edit_node)
									funced_end_edit(data,data->edit_node,0,0);

								// Start editing this entry
								data->edit_node=node;
								funced_start_edit(data);
								break;


							// Return pressed in edit line
							case GAD_FUNCED_EDIT:

								// See if we were editing something
								if (data->edit_node)
								{
									// Stop editing
									funced_end_edit(data,data->edit_node,END_DISABLE,msg.Qualifier);
									data->edit_node=0;
								}
								break;


							// New entry
							case GAD_FUNCED_NEW_ENTRY:
							case GAD_FUNCED_INSERT_ENTRY:

								// Create new entry
								functioned_copy_line(data,0,gadgetid,0);
								break;


							// Delete entry
							case GAD_FUNCED_DELETE_ENTRY:
								// Check we were editing something
								if (!data->edit_node) break;

								// Stop editing (signal delete)
								funced_end_edit(data,data->edit_node,END_DISABLE|END_DELETE,0);
								data->edit_node=0;
								break;


							// Function type
							case GAD_FUNCED_FUNCTION_TYPE:
								// Check we were editing something
								if (!data->edit_node) break;

								// Store type
								((FunctionEntry *)data->edit_node->data)->type=msg.Code;

								// Disable popup button if no functions
								DisableObject(
									data->objlist,
									GAD_FUNCED_EDIT_GLASS,
									(msg.Code==INST_COMMAND && !data->startup->func_list));
								break;


							// Glass gadget
							case GAD_FUNCED_EDIT_GLASS:

								// Check we were editing something
								if (data->edit_node)
								{
									char buffer[256];

									// Put up requester
									if (!(funced_command_req(
										data,
										buffer,
										((FunctionEntry *)data->edit_node->data)->type)))
										break;

									// Insert string in edit line
									funced_edit_insertstring(
										data->objlist,
										GAD_FUNCED_EDIT,
										buffer,
										DOpusBase,(struct Library *)IntuitionBase);
								}
								break;


							// Argument list
							case GAD_FUNCED_EDIT_ARGUMENT:

								// Check we were editing something
								if (data->edit_node)
								{
									char buffer[80];

									// Put up requester
									if (!(funced_command_req(
										data,
										buffer,
										-1))) break;

									// Insert string in edit line
									funced_edit_insertstring(
										data->objlist,
										GAD_FUNCED_EDIT,
										buffer,
										DOpusBase,(struct Library *)IntuitionBase);
								}
								break;


							// Export
							case MENU_FUNCED_EXPORT_ASCII:
							case MENU_FUNCED_EXPORT_CMD:

								// Got file requester?
								if (WINREQUESTER(data->window))
								{
									struct TagItem tags[6];
									struct FileRequester *req=WINREQUESTER(data->window);

									// Show busy pointer
									SetWindowBusy(data->window);

									// File requester tags
									tags[0].ti_Tag=ASLFR_Window;
									tags[0].ti_Data=(ULONG)data->window;
									tags[1].ti_Tag=ASLFR_TitleText;
									tags[1].ti_Data=(ULONG)GetString(startup->locale,MSG_FUNCED_SELECT_FILE);
									tags[2].ti_Tag=ASLFR_Flags1;
									tags[2].ti_Data=FRF_DOSAVEMODE|FRF_PRIVATEIDCMP;
									tags[3].ti_Tag=ASLFR_Flags2;
									tags[3].ti_Data=FRF_REJECTICONS;
									tags[4].ti_Tag=(gadgetid==MENU_FUNCED_EXPORT_CMD)?ASLFR_InitialDrawer:TAG_DONE;
									tags[4].ti_Data=(ULONG)"DOpus5:Commands";
									tags[5].ti_Tag=TAG_DONE;

									// Show filerequester
									if (AslRequest(req,tags))
									{
										// Build filename
										strcpy(data->buffer,req->fr_Drawer);
										AddPart(data->buffer,req->fr_File,256);

										// Store changes in function
										funced_store_edits(data);

										// Do export
										if (gadgetid==MENU_FUNCED_EXPORT_CMD)
											function_export_cmd(data->buffer,0,data->function);
										else
											L_FunctionExportASCII(data->buffer,0,data->function,startup->a4);
									}

									// Remove busy pointer
									ClearWindowBusy(data->window);
								}
								break;


							// Cut/Copy
							case MENU_FUNCED_CUT:
							case MENU_FUNCED_COPY:
								{
									APTR iff;

									// Set busy pointer
									SetWindowBusy(data->window);

									// Open clipboard
									if ((iff=IFFOpen((char *)0,IFF_CLIP_WRITE,ID_OPUS)))
									{
										// Stop editing
										funced_end_edit(data,data->edit_node,END_DISABLE,0);
										data->edit_node=0;

										// Store changes in function
										funced_store_edits(data);

										// Save function
										SaveFunction(iff,data->function);

										// Close clipboard
										IFFClose(iff);
									}

									// Just copy, not cut?
									if (gadgetid==MENU_FUNCED_COPY)
									{
										// Clear busy pointer
										ClearWindowBusy(data->window);
										break;
									}

									// Fall through, paste null function
								}

							// Paste
							case MENU_FUNCED_PASTE:
								{
									Cfg_Function *func=0;

									// Set busy pointer
									SetWindowBusy(data->window);

									// End any edit
									funced_end_edit(data,data->edit_node,END_DISABLE,0);
									data->edit_node=0;

									// Paste?
									if (gadgetid==MENU_FUNCED_PASTE)
									{
										APTR iff;

										// Open clipboard
										if ((iff=IFFOpen((char *)0,IFF_CLIP_READ,ID_OPUS)))
										{
											// Find function
											if (IFFNextChunk(iff,ID_FUNC))
											{
												// Read function
												func=ReadFunction(iff,0,0,0);
											}

											// Close clipboard
											IFFClose(iff);
										}

										// No valid function?
										if (!func)
										{
											// Flash error
											DisplayBeep(data->window->WScreen);
											ClearWindowBusy(data->window);
											break;
										}
									}

									// Detach existing list
									SetGadgetChoices(data->objlist,GAD_FUNCED_FLAGS,(APTR)~0);

									// Clear function list
									Att_RemList(data->function_list,REMLIST_SAVELIST|REMLIST_FREEDATA);

									// Free existing instructions
									FreeInstructionList(data->function);

									// Rebuild display list
									funced_build_display(data);

									// Clear flags
									data->function->function.flags=0;
									funced_update_flaglist(data);

									// Clear key
									data->function->function.code=0xffff;
									SetGadgetValue(data->objlist,GAD_FUNCED_KEY,0);

									// Clear label
									if (startup->flags&FUNCEDF_LABEL)
									{
										data->label[0]=0;
										SetGadgetValue(data->p_objlist,GAD_FUNCED_LABEL,0);
									}

									// Paste function in?
									if (func)
									{
										short type;

										// Save type
										type=data->function->function.func_type;

										// Copy function in
										CopyFunction(func,0,data->function);
										data->function->function.func_type=type;

										// Free copied function
										FreeFunction(func);

										// Initialise gadgets
										funced_init_gads(data);
									}
	
									// Clear busy pointer
									ClearWindowBusy(data->window);
								}
								break;


							// Use
							case GAD_FUNCED_USE:
								success=1;

							// Cancel
							case GAD_FUNCED_CANCEL:
								break_flag=1;
								break;
						}
						break;


					// Key press
					case IDCMP_RAWKEY:

						// Help?
						if (msg.Code==0x5f &&
							!(msg.Qualifier&VALID_QUALIFIERS))	
						{
							// Set busy pointer
							SetWindowBusy(data->window);

							// Send help command
							IPC_Command(startup->main_owner,IPC_HELP,(1<<31),"Function Editor",0,REPLY_NO_PORT);

							// Clear busy pointer
							ClearWindowBusy(data->window);
						}
						break;


					// BOOPSI message
					case IDCMP_IDCMPUPDATE:
						{
							struct TagItem *tags=(struct TagItem *)msg.IAddress;
							short item;

							// Check ID
							if (GetTagData(GA_ID,0,tags)!=GAD_FUNCED_LISTER)
								break;

							// Get item
							if ((item=GetTagData(DLV_DragNotify,-1,tags))!=-1)
							{
								// Start the drag
								config_drag_start(&data->drag,data->func_display_list,item,tags,TRUE);
							}
						}
						break;


					// Ticks
					case IDCMP_INTUITICKS:
						++data->drag.tick_count;
						break;
				}

				// Reply to any outstanding message
				if (gmsg) ReplyWindowMsg(gmsg);
			}
		}

		// AppMessage
		if (data->appwindow)
		{
			struct AppMessage *msg;

			while ((msg=(struct AppMessage *)GetMsg(data->appport)))
			{
				// Make sure window is active
				ActivateWindow(data->window);

				// Handle message
				funced_appmsg(data,msg);
				ReplyMsg((struct Message *)msg);
			}
		}

		// Check break flag
		if (break_flag) break;

		// Wait for message
		Wait(waitbits);
	}

	// Restore CD
	if (lock) UnLock(CurrentDir(lock));

	// Edit successful?
	if (success)
	{
		FunctionReturn ret;

		// Store changes in function
		funced_store_edits(data);

		// Fill out return data
		ret.object=startup->object;
		ret.object_flags=startup->object_flags;
		ret.function=data->function;

		// Send new function back
		IPC_Command(startup->owner_ipc,FUNCTIONEDIT_RETURN,0,&ret,0,REPLY_NO_PORT);
	}

	// End any drag in progress
	functioned_end_drag(data,0);

	// Free edit function
	FreeFunction(data->function);

	// Close window
	RemoveAppWindow(data->appwindow);
	CloseConfigWindow(data->window);

	// Close application port
	if (data->appport)
	{
		struct Message *msg;
		while ((msg=GetMsg(data->appport)))
			ReplyMsg(msg);
		DeleteMsgPort(data->appport);
	}

	// Say goodbye
	IPC_Goodbye(ipc,startup->owner_ipc,startup->object_flags);

	// Delete IPC data
	Forbid();
	IPC_Free(ipc);

	// Free data
	funced_cleanup(data);
	FreeVec(startup);
}
コード例 #14
0
short LIBFUNC L_Config_Filetypes(
	REG(a0, struct Screen *screen),
	REG(a1, IPCData *ipc),
	REG(a2, IPCData *owner_ipc),
	REG(d0, ULONG command_list),
	REG(a3, char *name))
{
	config_filetypes_data *data;
	IPCMessage *quit_msg=0;
	short undo_flag=0,pending_quit=0;
	short ret=0,fontsize;
	struct IBox pos;
	ConfigWindow dims;

	// Allocate data and memory handle
	if (!(data=AllocVec(sizeof(config_filetypes_data),MEMF_CLEAR)) ||
		!(data->memory=NewMemHandle(4096,256,MEMF_CLEAR)))
		return 0;

	// Save pointers
	data->ipc=ipc;
	data->owner_ipc=owner_ipc;
	data->command_list=command_list;

	// Initialise data
	NewList(&data->list_list);
	InitListLock(&data->proc_list,0);

	// Fill in new window
	data->newwin.parent=screen;
	data->newwin.dims=&dims;
	data->newwin.title=GetString(locale,MSG_FILETYPES_TITLE);
	data->newwin.locale=locale;
	data->newwin.flags=WINDOW_SCREEN_PARENT|WINDOW_VISITOR|WINDOW_REQ_FILL|WINDOW_AUTO_KEYS|WINDOW_SIZE_BOTTOM;

	// Get default size
	dims=_config_filetypes_window;

	// Get saved position
	if (LoadPos("dopus/windows/filetypes",&pos,&fontsize))
	{
		dims.char_dim.Width=0;
		dims.char_dim.Height=0;
		dims.fine_dim.Width=pos.Width;
		dims.fine_dim.Height=pos.Height;
	}
		
	// Open window and add objects
	if (!(data->window=OpenConfigWindow(&data->newwin)) ||
		!(data->objlist=AddObjectList(data->window,_config_filetypes_objects)))
	{
		CloseConfigWindow(data->window);
		FreeMemHandle(data->memory);
		FreeVec(data);
		return 0;
	}

	// Set minimum size
	SetConfigWindowLimits(data->window,&_config_filetypes_window,0);

	// Read filetype list
	SetWindowBusy(data->window);
	filetype_read_list(data->memory,&data->list_list);

	// Build display list
	filetype_build_list(data);
	ClearWindowBusy(data->window);

	// Name to edit?
	if (name) filetype_edit_name(data,name);

	// Event loop
	FOREVER
	{
		struct IntuiMessage *msg;
		IPCMessage *imsg;
		int quit_flag=0;

		// Any IPC messages?
		while ((imsg=(IPCMessage *)GetMsg(ipc->command_port)))
		{
			// Look at command
			switch (imsg->command)
			{
				// Quit
				case IPC_QUIT:
					quit_flag=1;
					quit_msg=imsg;
					imsg=0;
					data->change=0;
					break;


				// Activate
				case IPC_ACTIVATE:
					if (data->window)
					{
						// Bring window to front
						WindowToFront(data->window);
						ActivateWindow(data->window);

						// Edit name supplied?
						if (imsg->data) filetype_edit_name(data,(char *)imsg->data);
					}
					break;


				// Process saying goodbye
				case IPC_GOODBYE:
					{
						FiletypeNode *node;

						// Handle goodbye
						if ((node=(FiletypeNode *)IPC_GetGoodbye(imsg)))
						{
							// Node no longer has an editor
							node->editor=0;
						}

						// All process gone and pending quit?
						if (pending_quit && (IsListEmpty(&data->proc_list.list)))
						{
							quit_flag=1;
							pending_quit=2;
						}
					}
					break;


				// Got a filetype back from the editor
				case FILETYPEEDIT_RETURN:
					if (filetype_receive_edit(
						data,
						(Cfg_Filetype *)imsg->flags,
						(FiletypeNode *)imsg->data))
					{
						data->change=1;
						imsg->command=1;
					}
					else imsg->command=0;
					break;
			}

			// Reply message
			IPC_Reply(imsg);

			// Check quit flag
			if (quit_flag) break;
		}

		// Intuimessages
		if (data->window)
		{
			while ((msg=GetWindowMsg(data->window->UserPort)))
			{
				struct IntuiMessage msg_copy;
				UWORD id;

				// Copy message and reply
				msg_copy=*msg;
				ReplyWindowMsg(msg);

				if (pending_quit) continue;

				// Look at message
				switch (msg_copy.Class)
				{
					// Close window
					case IDCMP_CLOSEWINDOW:
						quit_flag=1;
						undo_flag=1;
						break;


					// Gadget
					case IDCMP_GADGETUP:

						id=((struct Gadget *)msg_copy.IAddress)->GadgetID;
						switch (id)
						{
							// Cancel
							case GAD_FILETYPES_CANCEL:
								undo_flag=1;

							// Use
							case GAD_FILETYPES_USE:
								quit_flag=1;
								break;


							// Filetype selected
							case GAD_FILETYPES_LIST:
								{
									Att_Node *node;

									// Enable buttons
									filetype_able_buttons(data,FALSE);

									// Get selection
									if (!(node=Att_FindNode(data->filetype_list,msg_copy.Code)))
										break;

									// Double-click?
									if (node==data->sel_filetype &&
										DoubleClick(
											data->seconds,data->micros,
											msg_copy.Seconds,msg_copy.Micros))
									{
										// Launch editor for this filetype
										filetype_edit(data,(FiletypeNode *)data->sel_filetype->data,0);
									}

									// New selection
									else
									{
										data->sel_filetype=node;
										data->seconds=msg_copy.Seconds;
										data->micros=msg_copy.Micros;
									}
								}
								break;


							// Add a new filetype
							case GAD_FILETYPES_DUPLICATE:
								if (!data->sel_filetype) break;
							case GAD_FILETYPES_ADD:
								{
									Cfg_FiletypeList *list;
									Cfg_Filetype *type=0;

									// Allocate a new filetype list
									if ((list=AllocMemH(data->memory,sizeof(Cfg_FiletypeList))))
									{
										// Initialise list
										NewList(&list->filetype_list);

										// Copy existing filetype?
										if ((((struct Gadget *)msg_copy.IAddress)->GadgetID==
											GAD_FILETYPES_DUPLICATE))
										{
											// Copy filetype
											type=CopyFiletype(
												((FiletypeNode *)data->sel_filetype->data)->type,
												data->memory);
										}

										// Allocate a new filetype
										else if ((type=NewFiletype(data->memory)))
										{
											// Initialise name
											strcpy(type->type.name,GetString(locale,MSG_UNTITLED));
										}

										// Get a filetype?
										if (type)
										{
											// Add filetype list to main list
											AddTail(&data->list_list,&list->node);

											// Add filetype to list
											AddTail(&list->filetype_list,&type->node);

											// Set list pointer
											type->list=list;
											list->flags=FTLISTF_CHANGED;
										}

										// Failed
										else FreeMemH(list);
									}

									// Got new filetype?
									if (type)
									{
										Att_Node *node;

										// Remove existing list
										SetGadgetChoices(
											data->objlist,
											GAD_FILETYPES_LIST,
											(APTR)~0);

										// Add entry for this filetype
										node=filetype_add_entry(data,type);

										// Handle new nodes
										filetype_new_node(data,node);
									}
								}
								break;


							// Edit filetype
							case GAD_FILETYPES_EDIT:

								// Valid selection?
								if (data->sel_filetype)
								{
									// Launch editor for this filetype
									filetype_edit(data,(FiletypeNode *)data->sel_filetype->data,0);
								}
								break;


							// Remove/Store
							case GAD_FILETYPES_REMOVE:
							case GAD_FILETYPES_STORE:

								// Valid selection?
								if (data->sel_filetype)
								{
									short ret;

									// Remove filetype
									if ((ret=
										filetype_remove(
											data,
											data->sel_filetype,
											(id==GAD_FILETYPES_STORE)))==1)
									{
										data->change=1;
										data->sel_filetype=0;
									}

									// Quit?
									else if (ret==-1)
									{
										quit_flag=1;
									}
								}
								break;
						}
						break;


					// Key press
					case IDCMP_RAWKEY:

						// Help?
						if (msg_copy.Code==0x5f &&
							!(msg_copy.Qualifier&VALID_QUALIFIERS))
						{
							// Set busy pointer
							SetWindowBusy(data->window);

							// Send help command
							IPC_Command(data->owner_ipc,IPC_HELP,(1<<31),"File Types",0,REPLY_NO_PORT);

							// Clear busy pointer
							ClearWindowBusy(data->window);
						}
						break;
				}

				// Check quit flag
				if (quit_flag) break;
			}
		}

		// Check quit flag
		if (quit_flag)
		{
			if (!pending_quit)
			{
				SetWindowBusy(data->window);
				if (!(IPC_ListQuit(&data->proc_list,0,!undo_flag,FALSE)))
					pending_quit=2;
				else
					pending_quit=1;
			}
		}

		// Set to break?
		if (pending_quit==2)
		{
			// Save filetypes?
			if (data->change && !undo_flag)
			{
				if (!(ret=filetype_save(data)))
				{
					// Abort save/quit
					ClearWindowBusy(data->window);
					pending_quit=0;
					continue;
				}
			}
			break;
		}

		// Wait for an event
		Wait(1<<ipc->command_port->mp_SigBit|
			((data->window)?1<<data->window->UserPort->mp_SigBit:0));
	}

	// Save window position
	if (data->window)
	{
		struct IBox pos;
		pos.Left=data->window->LeftEdge;
		pos.Top=data->window->TopEdge;
		pos.Width=data->window->Width-data->window->BorderLeft-data->window->BorderRight;
		pos.Height=data->window->Height-data->window->BorderTop-data->window->BorderBottom;
		SavePos("dopus/windows/filetypes",(struct IBox *)&pos,data->window->RPort->TxHeight);
	}

	// Close up
	CloseConfigWindow(data->window);

	// Free data
	Att_RemList(data->filetype_list,REMLIST_FREEDATA);
	FreeMemHandle(data->memory);
	FreeVec(data);

	// Reply quit message
	IPC_Reply(quit_msg);
	return ret;
}
コード例 #15
0
void _config_env_screenmode_fix_gadgets(config_env_data *data)
{
	BOOL state=FALSE;

	// If screen mode is WORKBENCH_CLONE, select both default checks and disable them
	if (data->config->screen_mode==MODE_WORKBENCHCLONE)
	{
		// Set default size flags
		SetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFWIDTH,1);
		SetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFHEIGHT,1);
		state=TRUE;
	}

	// Or if mode is a USE mode, disable them
	else
	if (data->config->screen_mode==MODE_WORKBENCHUSE ||
		data->config->screen_mode==MODE_PUBLICSCREEN)
		state=TRUE;

	// Set enable/disable state of default checks
	DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFWIDTH,state);
	DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFHEIGHT,state);

	// If default width is checked, fill out width field with default width
	// and disable it
	if (GetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFWIDTH))
	{
		SetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_WIDTH,data->mode_size_default.MaxX);
		state=TRUE;
	}

	// Or if mode is a USE mode, disable it
	else
	if (data->config->screen_mode==MODE_WORKBENCHUSE ||
		data->config->screen_mode==MODE_PUBLICSCREEN)
		state=TRUE;

	// Otherwise, make sure field is enabled
	else state=FALSE;

	// Set enable state
	DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_WIDTH,state);

	// If default height is checked, fill out height field with default height
	// and disable it
	if (GetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_DEFHEIGHT))
	{
		SetGadgetValue(data->option_list,GAD_ENVIRONMENT_SCREENMODE_HEIGHT,data->mode_size_default.MaxY);
		state=TRUE;
	}

	// Or if mode is a USE mode, disable it
	else
	if (data->config->screen_mode==MODE_WORKBENCHUSE ||
		data->config->screen_mode==MODE_PUBLICSCREEN)
		state=TRUE;

	// Otherwise, make sure field is enabled
	else state=FALSE;

	// Set enable state
	DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_HEIGHT,state);

	// Fix depth slider limits
	SetGadgetChoices(
		data->option_list,
		GAD_ENVIRONMENT_SCREENMODE_COLORS,
		(APTR)(((ULONG)data->mode_max_colours<<16)|2));
	SetGadgetValue(
		data->option_list,
		GAD_ENVIRONMENT_SCREENMODE_COLORS,
		data->config->screen_depth);

	// Is mode is a USE mode, disable colours selector and font gadgets
	state=(data->config->screen_mode==MODE_WORKBENCHUSE || data->config->screen_mode==MODE_PUBLICSCREEN);
	DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_COLORS,state);
	DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_FONT,state);
	DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_FONTNAME,state);
	DisableObject(data->option_list,GAD_ENVIRONMENT_SCREENMODE_FONTSIZE,state);

	// Check maximum/minimum values
	_config_env_screenmode_check_values(data);
}
コード例 #16
0
// Edit a specific filetype
void filetype_edit_name(config_filetypes_data *data,char *name)
{
	Att_Node *node;
	char *path;

	// Store path pointer
	path=name;

	// Full path specified?
	if (strchr(name,':') || strchr(name,'/'))
	{
		// Get pointer to filename only
		name=FilePart(name);
	}

	// Find node
	if ((node=(Att_Node *)FindNameI((struct List *)data->filetype_list,name)))
	{
		// Select the new entry
		data->sel_filetype=node;
		SetGadgetValue(data->objlist,GAD_FILETYPES_LIST,Att_FindNodeNumber(data->filetype_list,node));

		// Launch editor
		filetype_edit(data,(FiletypeNode *)node->data,0);
	}

	// Load from disk?
	else
	{
		Cfg_FiletypeList *list;

		// Try to load filetype from disk
		if ((list=ReadFiletypes(path,data->memory)))
		{
			Cfg_Filetype *type;
			Att_Node *node=0;

			// Add filetype list to main list
			AddTail(&data->list_list,&list->node);

			// Fix list path and flags
			strcpy(list->path,"dopus5:filetypes/");
			strcat(list->path,name);
			list->flags=FTLISTF_CHANGED;

			// Remove list from gadget
			SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,(APTR)~0);

			// Go through filetypes in list
			for (type=(Cfg_Filetype *)list->filetype_list.lh_Head;
				type->node.ln_Succ;
				type=(Cfg_Filetype *)type->node.ln_Succ)
			{
				// Add entry for this filetype
				node=filetype_add_entry(data,type);
			}

			// Handle new node
			filetype_new_node(data,node);
		}
	}

	// Free name
	FreeVec(path);
}
コード例 #17
0
// Remove a filetype
short filetype_remove(
	config_filetypes_data *data,
	Att_Node *node,
	short store)
{
	FiletypeNode *ftnode;
	struct DOpusSimpleRequest simple;
	char buf[100],*gadgets[3];
	int ret_vals[2];
	short change=0;

	// Get filetype node
	ftnode=(FiletypeNode *)node->data;

	// Fill out requester structure
	simple.title=GetString(locale,MSG_FILETYPE_EDITOR_TITLE);
	simple.message=buf;
	simple.gadgets=gadgets;
	simple.return_values=ret_vals;
	simple.string_buffer=0;
	simple.flags=SRF_IPC;
	simple.font=0;
	simple.ipc=data->ipc;

	// Build message
	lsprintf(buf,GetString(locale,MSG_FILETYPE_REMOVE_REQ),ftnode->type->type.name);

	// Fill in gadgets
	gadgets[0]=GetString(locale,MSG_FILETYPES_REMOVE);
	gadgets[1]=GetString(locale,MSG_CANCEL);
	gadgets[2]=0;
	ret_vals[0]=1;
	ret_vals[1]=0;

	// Make window busy
	SetWindowBusy(data->window);

	// Display requester
	if (store || (change=DoSimpleRequest(data->window,&simple))==1)
	{
		// Is the editor open for this filetype?
		if (ftnode->editor)
		{
			// Tell it to quit
			IPC_Quit(ftnode->editor,-1,0);
		}

		// Remove filetype list from lister
		SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,(APTR)~0);

		// Mark this list as changed
		ftnode->type->list->flags|=FTLISTF_CHANGED;

		// Stored?
		if (store)
		{
			ftnode->type->list->flags|=FTLISTF_STORE;
			change=1;
		}

		// Removed
		else
		{
			// Free filetype
			FreeFiletype(ftnode->type);
		}

		// Free node data and node
		FreeVec(ftnode);
		Att_RemNode(node);

		// Reattach list with no selection
		SetGadgetValue(data->objlist,GAD_FILETYPES_LIST,(ULONG)-1);
		SetGadgetChoices(data->objlist,GAD_FILETYPES_LIST,data->filetype_list);

		// Disable buttons
		filetype_able_buttons(data,TRUE);
	}

	// Make window unbusy
	ClearWindowBusy(data->window);

	return change;
}