gui.c

一个很好的SDL建立应用程序界面的例子

	--text;
	*text = '\0';
}

// Set ID locations from Intel hex record

void setIdLocation(char *line, int len)
{
	int	i;
	char	*text;

	line += 9;
	text = (char *) &IdText[0];

	for (i=0; i<len; i += 2)
	{
		*text++ = '0';
		*text++ = 'x';
		*text++ = tolower(*(line + 2));
		*text++ = tolower(*(line + 3));
		*text++ = tolower(*(line + 0));
		*text++ = tolower(*(line + 1));
		*text++ = ' ';
		line += 4;
	}

	--text;
	*text = '\0';
}

// Parse hex line received from PS+ into buffer array.

bool parseHexLine(char *line, byte *bfr)
{
	int	i, len, pc, datapc;

	i = 0;		// to keep gcc from bitching

	if (sscanf(line, "%*c%2x%4x%2x", &len, (int *) &pc, &recordType) != EOF)
	{											// get count and address
		pc += extendedAddress;			// add segment to address

		switch (recordType)
		{
			case ENDRECORD:
				break;						// done if end of hex record

			case SEGADDRESS:				// segment address record
				sscanf((char *) &line[9], "%4x", &extendedAddress);
				extendedAddress <<= 4;
				break;

// [TODO] Handle extended records

			case EXTADDRESS:				// extended segment address record
				sscanf((char *) &line[9], "%4x", &extendedAddress);
				extendedAddress <<= 16;
				break;

			case DATARECORD:
				if (!extendedAddress)	// data record [TODO] handle extended addressing
				{
					if (len > 64)						// oops! line too long
					{
						sprintf(alertMessage, "invalid count (%d) in line %d ", i, recordCount);
						errorAlert->w = (strlen(alertMessage) + 4) * FONT_WIDTH;
						popUpWidget(errorAlert);
						return FALSE;
					}

					if (pc == CfgAddress)
					{
						if ((unsigned int) len <= CfgSize)
							setConfigBits(line, len);
						else
							fprintf(stderr, "\nInvalid length in Configuration bits record: %s\n", line);
					}
					else if (pc == IdAddress)
					{
						if ((unsigned int) len <= IdSize)
							setIdLocation(line, len);
						else
							fprintf(stderr, "\nInvalid length in ID locations record: %s\n", line);
					}
					else
					{
						for (i=0; i<len; i++, pc++)			// now move data to program area
						{
							pc &= (PIC_PROGRAM_SIZE - 1);
							getcode(line + 9 + i * 2, &bfr[pc]);	// move code to program/data space
						}
					}
				}
				else
				{
					if (extendedAddress == CfgAddress)
					{
						if ((unsigned int) len <= CfgSize)
							setConfigBits(line, len);
						else
							fprintf(stderr, "\nInvalid length in Configuration bits record: %s\n", line);
					}
					else if (extendedAddress == IdAddress)
					{
						if ((unsigned int) len <= IdSize)
							setIdLocation(line, len);
						else
							fprintf(stderr, "\nInvalid length in ID locations record: %s\n", line);
					}
					else if (extendedAddress == EepromAddress)
					{
						datapc = pc & (EepromSize - 1);

						if ((unsigned int) pc + len <= EepromAddress + EepromSize)
						{
							for (i=0; i<len; i++, datapc++)
								getcode(line + 9 + i * 2, &picDataBuffer[datapc]);	// move code to eeprom space
						}
						else
							fprintf(stderr, "\nInvalid length in eeprom data record: %s\n", line);

					}
				}
				break;
		}
	}

	return TRUE;
}

// Update configuration file

bool writeConfigFile(void)
{
	FILE	*fp;

	fp = fopen(configFileName, "w");

	if (fp)
	{
		fprintf(fp, "[PORT]\n%s\n\n", serialPort);
		fprintf(fp, "[DEVICE]\n%s\n\n", deviceType);
		fflush(fp);
		fclose(fp);
	}
	else
	{
		sprintf(alertMessage, "    Can't open configuration file!    ");
		errorAlert->x = 20;
		errorAlert->y = 10;
		errorAlert->w = (strlen(alertMessage) + 4) * FONT_WIDTH;
		popUpWidget(errorAlert);
		waitForAlertResponse(errorAlert);
		return FALSE;
	}

	return TRUE;
}

////////////////////////////////////////
//
// Wait for user to respond to an alert,
// then return reponse code to caller.
//
////////////////////////////////////////

int waitForAlertResponse(ALERT *alert)
{
	SDL_Event	event;

	alert->response = ALERT_NO_RESPONSE;
	popUpWidget(alert);
	updateScreen();

	while (alert->response == ALERT_NO_RESPONSE)
	{
		if (SDL_PollEvent(&event))
			processCB(&event);
	}

	pushDownWidget(alert);
	return alert->response;
}

void connectFailAlert(void)
{
	sprintf(alertMessage, "  Failed to connect to PICSTART \n"
								 "   Please check serial cables");
	errorAlert->x = 100;
	errorAlert->y = 40;
	errorAlert->w = 40 * FONT_WIDTH;
	waitForAlertResponse(errorAlert);
}

void AlertCB(SDL_Event *event, ALERT *ab)
{
	bool	remove = FALSE;

	if (event->type == SDL_KEYDOWN)
	{
		ab->response = ALERT_OK;
		remove = TRUE;
	}
	else if (ab->response == ALERT_CANCEL)
		remove = TRUE;
	else if (ab->response == ALERT_OK)
		remove = TRUE;

	if (remove)
		pushDownWidget(ab);
}

void NoticeCB(SDL_Event *event, NOTICE *note)
{
	pushDownWidget(note);
}

void pushDownMenus(void)
{
	helpMenuCB(NULL, NULL);
	closeFileMenuCB(NULL);
	closePortMenuCB(NULL);

	aboutButtonActive = FALSE;
	fileSelectionActive = FALSE;
	fileButtonActive = FALSE;

	removeWList(eraseRegionMenu);			// removeWList is faster than pushDownWidget
	removeWList(regionMenu);
	pushDownWidget(aboutMenu);
}

void fileButtonCB(SDL_Event *event)
{
	if (fileSelectionActive)
		return;

	fileButtonActive ^= TRUE;

	if (fileButtonActive)
		popUpWidget(fileMenu);
	else
		pushDownWidget(fileMenu);
}

// Save program data to hex file

void saveFile(char *fname)
{
	int			i, size, offset, count, start;
	byte			data, chksum;
	FILE			*fp;
	struct stat	filestat;
	PGMSEG		*seglist;
	bool			oktowrite;
	char			line[64];

	if (!selectedPicDevice)
	{
		sprintf(alertMessage, "    No PIC device selected!    ");
		errorAlert->x = 20;
		errorAlert->y = 10;
		errorAlert->w = 34 * FONT_WIDTH;
		waitForAlertResponse(errorAlert);
		return;
	}

	i = stat(fname, &filestat);

	if ((i > -1) && (fname != tempFileName))
	{
		strcpy(alertMessage, " Overwrite ");
		strcat(alertMessage, fname);
		strcat(alertMessage, "? ");
		errorAlert->x = 4;
		errorAlert->w = (strlen(alertMessage) + 4) * FONT_WIDTH;
		i = waitForAlertResponse(errorAlert);

		if (i != ALERT_OK)
			return;
	}

	fp = fopen(fname, "w");

	if (!fp)
	{
		sprintf(alertMessage, "    Can't open output file!    ");
		errorAlert->x = 20;
		errorAlert->y = 10;
		errorAlert->w = 34 * FONT_WIDTH;
		waitForAlertResponse(errorAlert);
		return;
	}

	if (programDisplayFlag)
		size = picProgramSize;
	else
		size = picDataSize;

	if (size & 1)			// size MUST be an even number of words
		size++;

	if (programDisplayFlag)
		size <<= 1;				// size is in words, make it bytes for writing hex file

	i = 0;
	fputs(":020000040000FA\n", fp);		// to maintain compatibility with picp
	seglist = segmentList;

	while (i < size)
	{
		start = i;
		count = size - i + 1;

		if (count < 1)
			break;

		if (count > 16)
			count = 16;

		sprintf(line, ":%02X%04X00", count, i);
		chksum = count + ((i >> 8) & 0xff) + (i & 0xff);
		offset = 9;

		while (count)
		{
			if (programDisplayFlag)
				data = picProgramData[i];
			else
				data = picDataBuffer[i];

			data >>= 4;
			data &= 0x0f;

			if (data > 9)
				data += 7;

			data += '0';
			line[offset++] = data;

			if (programDisplayFlag)
				data = picProgramData[i];
			else
				data = picDataBuffer[i];

			chksum += data;
			data &= 0x0f;

			if (data > 9)
				data += 7;

			data += '0';
			line[offset++] = data;
			--count;
			i++;
		}

		data = (byte) (0x100 - ((int) chksum & 0xff));
		chksum = data;
		data >>= 4;
		data &= 0x0f;

		if (data > 9)
			data += 7;

		data += '0';
		line[offset++] = data;
		data = chksum;
		data &= 0x0f;

		if (data > 9)
			data += 7;

		data += '0';
		line[offset++] = data;
		line[offset++] = '\n';
		line[offset] = '\0';

// If current block is not within an entry of the segment list, don't write it out.
// 'start' is the beginning address of the block, and 'i' is the ending address + 1

		oktowrite = TRUE;

		if (programDisplayFlag)			// EEPROM data always gets written
		{
			if (seglist && start >= seglist->end)
				seglist = seglist->next;

			if (!seglist)
				oktowrite = FALSE;		// no more valid segments
			else
			{
				if (start < seglist->start && start < seglist->end &&
						i < seglist->start && i < seglist->end)
					oktowrite = FALSE;	// current block not within a segment
			}
		}

		if (oktowrite)
			fputs(line, fp);
	}

	saveButton->fg = black;
	saveAsButton->fg = black;

	fputs(":00000001FF\n", fp);
	fflush(fp);
	fclose(fp);
}

void saveButtonCB(SDL_Event *event, MENU *m)
{
	if ((saveButton->fg == gray) || (strlen(fileStr) < 2))
		return;

	saveFile(fileStr);
	fileButtonActive = FALSE;
	pushDownWidget(fileMenu);
}

void saveAsButtonCB(SDL_Event *event, MENU *m)
{
	int	i;

	for (i=0; i<USER_FILENAME_SIZE; i++)
		userFileNameBuffer[i] = '\0';

	userFileName->cursorx = 0;

	popUpWidget(userFileNameWin);
	popUpWidget(userFileName);
}

void saveConfigButtonCB(SDL_Event *event)
{
	writeConfigFile();
	fileButtonActive = FALSE;
	pushDownWidget(fileMenu);
}

void userFileCB(SDL_Event *event)
{
// just to keep underlying widgets from popping up
}

// Save source file with a new, user specified name.
// From this point on, use the new name for all functions.

void saveUserFileName(void)
{
	char	*cptr;

	getcwd(linebuffer, FN_LEN);
	strcat(linebuffer, "/");
	strcat(linebuffer, userFileNameBuffer);
	cptr = strrchr(linebuffer, '.');
	strcpy(fileExt, ".hex");

	if (!cptr)		// user did not enter file extension,
		strcat(linebuffer, fileExt);	// so add extension of source file

	strcpy(fileStr, linebuffer);
	filelabel->text = (char *) &fileStr;
	saveFile(linebuffer);
}

void userFileInputCB(SDL_Event *event, INPUTBOX *ib)
{
	if (event->type == SDL_KEYDOWN)
	{
		if (event->key.keysym.unicode == SDLK_RETURN && strlen(userFileNameBuffer) > 0)
		{
			saveUserFileName();
			pushDownWidget(userFileNameWin);
			fileButtonActive = FALSE;
			pushDownWidget(fileMenu);
		}
	}
}

void userFileOkCB(SDL_Event *event)
{
	if (strlen(userFileNameBuffer) > 0)
	{
		saveUserFileName();
		pushDownWidget(userFileNameWin);
		fileButtonActive = FALSE;
		pushDownWidget(fileMenu);
	}
}

void userFileCancelCB(SDL_Event *event)
{
	pushDownWidget(userFileNameWin);
	fileButtonActive = FALSE;
	pushDownWidget(fileMenu);
}

void closeFileMenuCB(SDL_Event *event)
{
	if (fileButtonActive)
	{
		fileButtonActive = FALSE;
		pushDownWidget(fileMenu);
	}
}

void FileHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(FileHelpMenu);
}

void OpenHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(OpenHelpMenu);
}

void SaveHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(SaveHelpMenu);
}

void SaveAsHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(SaveAsHelpMenu);
}

void SaveConfigHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(SaveConfigHelpMenu);
}

void ExitHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(ExitHelpMenu);
}

void CloseMenuHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(CloseMenuHelpMenu);
}

void HelpHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(HelpHelpMenu);
}

void AboutHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(AboutHelpMenu);
}

void serialPortHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(serialPortHelpMenu);
}

void enableHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(enableHelpMenu);
}

void deviceHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(deviceHelpMenu);
}

void readHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(readHelpMenu);
}

void programHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(programHelpMenu);
}

void eraseHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(eraseHelpMenu);
}

void verifyHelpCB(SDL_Event *event)
{
	ClearHelpMenus();
	popUpWidget(verifyHelpMenu);
}

void blankHelpCB(SDL_Event *event)