自学教程：C++ warn_user函数代码示例

void ro_gui_cert_release_window(struct ro_sslcert *s){	os_error *error;	if (s == NULL)		return;	LOG(("Releasing SSL data: 0x%x", (unsigned) s));	ro_gui_wimp_event_finalise(s->window);	ro_treeview_destroy(s->tv);	error = xwimp_delete_window(s->window);	if (error) {		LOG(("xwimp_delete_window: 0x%x:%s",		     error->errnum, error->errmess));		warn_user("WimpError", error->errmess);	}	error = xwimp_delete_window(s->pane);	if (error) {		LOG(("xwimp_delete_window: 0x%x:%s",		     error->errnum, error->errmess));		warn_user("WimpError", error->errmess);	}	free(s);}

static bool save_complete_save_buffer(save_complete_ctx *ctx,		const char *leafname, const char *data, size_t data_len,		lwc_string *mime_type){	FILE *fp;	bool error;	char fullpath[PATH_MAX];	strncpy(fullpath, ctx->path, sizeof fullpath);	error = path_add_part(fullpath, sizeof fullpath, leafname);	if (error == false) {		warn_user("NoMemory", NULL);		return false;	}	fp = fopen(fullpath, "wb");	if (fp == NULL) {		LOG(("fopen(): errno = %i", errno));		warn_user("SaveError", strerror(errno));		return false;	}	fwrite(data, sizeof(*data), data_len, fp);	fclose(fp);	if (ctx->set_type != NULL)		ctx->set_type(fullpath, mime_type);	return true;}

void gui_download_window_done(struct gui_download_window *dw){	os_error *error;	if (dw->ctx != NULL)		download_context_destroy(dw->ctx);	dw->ctx = NULL;	ro_gui_download_update_status(dw);	error = xosfind_closew(dw->file);	if (error) {		LOG(("xosfind_closew: 0x%x: %s",				error->errnum, error->errmess));		warn_user("SaveError", error->errmess);	}	dw->file = 0;	if (dw->saved) {		error = xosfile_set_type(dw->path,				dw->file_type);		if (error) {			LOG(("xosfile_set_type: 0x%x: %s",				error->errnum, error->errmess));			warn_user("SaveError", error->errmess);		}		if (dw->send_dataload)			ro_gui_download_send_dataload(dw);		schedule(200, ro_gui_download_window_destroy_wrapper, dw);	}}

static bool save_complete_inventory(save_complete_ctx *ctx){	FILE *fp;	bool error;	save_complete_entry *entry;	char fullpath[PATH_MAX];	strncpy(fullpath, ctx->path, sizeof fullpath);	error = path_add_part(fullpath, sizeof fullpath, "Inventory");	if (error == false) {		warn_user("NoMemory", NULL);		return false;	}	fp = fopen(fullpath, "w");	if (fp == NULL) {		LOG(("fopen(): errno = %i", errno));		warn_user("SaveError", strerror(errno));		return false;	}	for (entry = ctx->list; entry != NULL; entry = entry->next) {		fprintf(fp, "%p %s/n", entry->content, 				nsurl_access(hlcache_handle_get_url(						entry->content)));	}	fclose(fp);	return true;}

void ro_gui_popup_menu(wimp_menu *menu, wimp_w w, wimp_i i){	wimp_window_state state;	wimp_icon_state icon_state;	os_error *error;	state.w = w;	icon_state.w = w;	icon_state.i = i;	error = xwimp_get_window_state(&state);	if (error) {		LOG(("xwimp_get_window_state: 0x%x: %s",				error->errnum, error->errmess));		warn_user("MenuError", error->errmess);		return;	}	error = xwimp_get_icon_state(&icon_state);	if (error) {		LOG(("xwimp_get_icon_state: 0x%x: %s",				error->errnum, error->errmess));		warn_user("MenuError", error->errmess);		return;	}	ro_gui_menu_create(menu,			state.visible.x0 + icon_state.icon.extent.x1 + 64,			state.visible.y1 + icon_state.icon.extent.y1 -			state.yscroll, w);	current_menu_icon = i;}

/**  * creates the file menu * /param group The gtk 'global' accelerator reference * /param parent The parent menu to attach to or NULL */static struct nsgtk_file_menu *nsgtk_menu_file_submenu(GtkAccelGroup *group){	struct nsgtk_file_menu *fmenu;	fmenu = malloc(sizeof(struct nsgtk_file_menu));	if (fmenu == NULL) {		warn_user(messages_get("NoMemory"), 0);		return NULL;	}	fmenu->file_menu = GTK_MENU(gtk_menu_new());	if (fmenu->file_menu == NULL) {		warn_user(messages_get("NoMemory"), 0);		free(fmenu);		return NULL;	}	IMAGE_ITEM(file, newwindow, gtkNewWindow, fmenu, group);	IMAGE_ITEM(file, newtab, gtkNewTab, fmenu, group);	IMAGE_ITEM(file, openfile, gtkOpenFile, fmenu, group);	IMAGE_ITEM(file, closewindow, gtkCloseWindow, fmenu, group);	ADD_SEP(file, fmenu);	IMAGE_ITEM(file, savepage, gtkSavePage, fmenu, group);	IMAGE_ITEM(file, export, gtkExport, fmenu, group);	ADD_SEP(file, fmenu);	IMAGE_ITEM(file, printpreview, gtkPrintPreview, fmenu, group);	IMAGE_ITEM(file, print, gtkPrint, fmenu, group);	ADD_SEP(file, fmenu);	IMAGE_ITEM(file, quit, gtkQuitMenu, fmenu, group);	SET_SUBMENU(export, fmenu);	return fmenu;}

void ro_gui_menu_create(wimp_menu *menu, int x, int y, wimp_w w){	os_error *error;	struct menu_definition *definition;	/* translate menu, if necessary (this returns quickly	 * if there's nothing to be done) */	definition = ro_gui_menu_find_menu(menu);	if (definition) {		if (!ro_gui_menu_translate(definition)) {			warn_user("NoMemory", 0);			return;		}	}	/* store the menu characteristics */	current_menu = menu;	current_menu_window = w;	current_menu_icon = wimp_ICON_WINDOW;	/* create the menu */	current_menu_open = true;	error = xwimp_create_menu(menu, x - 64, y);	if (error) {		LOG(("xwimp_create_menu: 0x%x: %s",				error->errnum, error->errmess));		warn_user("MenuError", error->errmess);		ro_gui_menu_closed();	}}

bool save_complete_inventory(const char *path,		struct save_complete_entry *list){	char urlpath[256];	FILE *fp;	char *pathstring, *standardpath = (path[0] == '/') ?			(char *)(path + 1) : (char *)path;	struct save_complete_entry *entry;	snprintf(urlpath, sizeof urlpath, "file:///%s/Inventory", 			standardpath);	pathstring = url_to_path(urlpath);	if (pathstring == NULL) {		warn_user("NoMemory", 0);		return false;	}	fp = fopen(pathstring, "w");	free(pathstring);	if (!fp) {		LOG(("fopen(): errno = %i", errno));		warn_user("SaveError", strerror(errno));		return false;	}	for (entry = list; entry; entry = entry->next) {		fprintf(fp, "%p %s/n", entry->content, 				content_get_url(entry->content));	}	fclose(fp);	return true;}

struct sslcert_session_data *sslcert_create_session_data(unsigned long num,			    const char *url, 			    llcache_query_response cb, 			    void *cbpw){	struct sslcert_session_data *data;	data = malloc(sizeof(struct sslcert_session_data));	if (data == NULL) {		warn_user("NoMemory", 0);		return NULL;	}	data->url = strdup(url);	if (data->url == NULL) {		free(data);		warn_user("NoMemory", 0);		return NULL;	}	data->num = num;	data->cb = cb;	data->cbpw = cbpw;	return data;}

void ro_url_load(const char *url){	char *command;	char *colon;	os_error *error;	colon = strchr(url, ':');	if (!colon) {		LOG(("invalid url '%s'", url));		return;	}	command = malloc(40 + (colon - url) + strlen(url));	if (!command) {		warn_user("NoMemory", 0);		return;	}	sprintf(command, "Alias$URLOpen_%.*s", (int) (colon - url), url);	if (!getenv(command)) {		free(command);		return;	}	sprintf(command, "URLOpen_%.*s %s", (int) (colon - url), url, url);	error = xwimp_start_task(command, 0);	if (error) {		LOG(("xwimp_start_task: 0x%x: %s",				error->errnum, error->errmess));		warn_user("WimpError", error->errmess);	}	free(command);}

static void nsgtk_options_theme_combo(void) {/* populate theme combo from themelist file */	GtkBox *box = GTK_BOX(glade_xml_get_widget(gladeFile, "themehbox"));	char buf[50];	combotheme = gtk_combo_box_new_text();	size_t len = SLEN("themelist") + strlen(res_dir_location) + 1;	char themefile[len];	if ((combotheme == NULL) || (box == NULL)) {		warn_user(messages_get("NoMemory"), 0);		return;	}	snprintf(themefile, len, "%sthemelist", res_dir_location);	FILE *fp = fopen((const char *)themefile, "r");	if (fp == NULL) {		LOG(("Failed opening themes file"));		warn_user("FileError", (const char *) themefile);		return;	}	while (fgets(buf, sizeof(buf), fp) != NULL) {		/* Ignore blank lines */		if (buf[0] == '/0')			continue;				/* Remove trailing /n */		buf[strlen(buf) - 1] = '/0';				gtk_combo_box_append_text(GTK_COMBO_BOX(combotheme), buf);	}	fclose(fp);	gtk_combo_box_set_active(GTK_COMBO_BOX(combotheme), 			option_current_theme);	gtk_box_pack_start(box, combotheme, FALSE, TRUE, 0);	gtk_widget_show(combotheme);		}

static node_callback_resp hotlist_node_callback(void *user_data,						struct node_msg_data *msg_data){	struct node *node = msg_data->node;	const char *text;	char *norm_text;	bool is_folder = tree_node_is_folder(node);	bool cancelled = false;	switch (msg_data->msg) {	case NODE_ELEMENT_EDIT_CANCELLED:		cancelled = true;		/* fall through */	case NODE_ELEMENT_EDIT_FINISHED:		if (creating_node && !cancelled &&		    (is_folder == false) &&		    (msg_data->flag == TREE_ELEMENT_TITLE)) {			tree_url_node_edit_url(hotlist_tree, node);		} else {			creating_node = false;		}		return NODE_CALLBACK_HANDLED;	case NODE_ELEMENT_EDIT_FINISHING:		if (creating_node && (is_folder == false))			return tree_url_node_callback(hotlist_tree, msg_data);		if (is_folder == true) {			text = msg_data->data.text;			while (isspace(*text))				text++;			norm_text = strdup(text);			if (norm_text == NULL) {				LOG(("malloc failed"));				warn_user("NoMemory", 0);				return NODE_CALLBACK_REJECT;			}			/* don't allow zero length entry text, return false */			if (norm_text[0] == '/0') {				warn_user("NoNameError", 0);				msg_data->data.text = NULL;				return NODE_CALLBACK_CONTINUE;			}			msg_data->data.text = norm_text;		}		break;	case NODE_DELETE_ELEMENT_IMG:		return NODE_CALLBACK_HANDLED;	default:		if (is_folder == false)			return tree_url_node_callback(hotlist_tree, msg_data);	}	return NODE_CALLBACK_NOT_HANDLED;}

END_HANDLERBUTTON_CLICKED(buttonaddtheme){	char *filename, *directory;	size_t len;	GtkWidget *fc = gtk_file_chooser_dialog_new(			messages_get("gtkAddThemeTitle"),			GTK_WINDOW(wndPreferences),			GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,			GTK_STOCK_OK, GTK_RESPONSE_ACCEPT,			GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, NULL);	len = SLEN("themes") + strlen(res_dir_location) + 1;	char themesfolder[len];	snprintf(themesfolder, len, "%sthemes", res_dir_location);	gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(fc), 			themesfolder);	gint res = gtk_dialog_run(GTK_DIALOG(fc));	if (res == GTK_RESPONSE_ACCEPT) {		filename = gtk_file_chooser_get_current_folder(				GTK_FILE_CHOOSER(fc));		if (strcmp(filename, themesfolder) != 0) {			directory = strrchr(filename, '/');			*directory = '/0';			if (strcmp(filename, themesfolder) != 0) {				warn_user(messages_get(						"gtkThemeFolderInstructions"), 						0);				gtk_widget_destroy(GTK_WIDGET(fc));				if (filename != NULL)					g_free(filename);				return FALSE;			} else {				directory++;			}		} else {			if (filename != NULL)				g_free(filename);			filename = gtk_file_chooser_get_filename(					GTK_FILE_CHOOSER(fc));			if (strcmp(filename, themesfolder) == 0) {				warn_user(messages_get("gtkThemeFolderSub"),						0);				gtk_widget_destroy(GTK_WIDGET(fc));				g_free(filename);				return FALSE;			}			directory = strrchr(filename, '/') + 1;		}		gtk_widget_destroy(GTK_WIDGET(fc));		nsgtk_theme_add(directory);		if (filename != NULL)			g_free(filename);	}}

bool ro_gui_theme_install_apply(wimp_w w){	char theme_save[256];	char *theme_file;	struct theme_descriptor *theme_install;	os_error *error;	char *fix;	const char *source_data;	unsigned long source_size;	assert(theme_install_content);	/* convert spaces to hard spaces */	theme_file = strdup(theme_install_descriptor.name);	if (!theme_file) {	  	LOG(("malloc failed"));	  	warn_user("NoMemory", 0);		return false;	}	for (fix = theme_file; *fix != '/0'; fix++)		if (*fix == ' ')			*fix = 160;	/* hard space */	/* simply overwrite previous theme versions */	snprintf(theme_save, sizeof theme_save, "%s.%s",                 nsoption_charp(theme_save), theme_file);	theme_save[sizeof theme_save - 1] = '/0';	source_data = content_get_source_data(theme_install_content, 			&source_size);	error = xosfile_save_stamped(theme_save, 0xffd,			(byte *) source_data,			(byte *) source_data + source_size);	if (error) {		LOG(("xosfile_save_stamped: 0x%x: %s",				error->errnum, error->errmess));		warn_user("ThemeInstallErr", 0);		free(theme_file);		return false;	}	/* apply the new theme */	ro_gui_theme_get_available();	theme_install = ro_gui_theme_find(theme_file);	if (!theme_install || !ro_gui_theme_apply(theme_install)) {		warn_user("ThemeApplyErr", 0);	} else {            nsoption_set_charp(theme, strdup(theme_install->leafname));	}	free(theme_file);	ro_gui_save_options();	return true;}

static bool save_complete_save_html_document(save_complete_ctx *ctx,		hlcache_handle *c, bool index){	bool error;	FILE *fp;	dom_document *doc;	lwc_string *mime_type;	char filename[32];	char fullpath[PATH_MAX];	strncpy(fullpath, ctx->path, sizeof fullpath);	if (index)		snprintf(filename, sizeof filename, "index");	else 		snprintf(filename, sizeof filename, "%p", c);	error = path_add_part(fullpath, sizeof fullpath, filename);	if (error == false) {		warn_user("NoMemory", NULL);		return false;	}	fp = fopen(fullpath, "wb");	if (fp == NULL) {		warn_user("NoMemory", NULL);		return false;	}	ctx->base = html_get_base_url(c);	ctx->fp = fp;	ctx->iter_state = STATE_NORMAL;	doc = html_get_document(c);	if (save_complete_libdom_treewalk((dom_node *) doc,			save_complete_node_handler, ctx) == false) {		warn_user("NoMemory", 0);		fclose(fp);		return false;	}	fclose(fp);	mime_type = content_get_mime_type(c);	if (mime_type != NULL) {		if (ctx->set_type != NULL)			ctx->set_type(fullpath, mime_type);		lwc_string_unref(mime_type);	}	return true;}

void ro_gui_history_open(struct browser_window *bw,		struct history *history, bool at_pointer){	int width, height;	os_box box = {0, 0, 0, 0};	wimp_window_state state;	os_error *error;	assert(history);	history_current = history;	history_bw = bw;	history_size(history, &width, &height);	width *= 2;	height *= 2;	/* set extent */	box.x1 = width;	box.y0 = -height;	error = xwimp_set_extent(history_window, &box);	if (error) {		LOG(("xwimp_set_extent: 0x%x: %s",				error->errnum, error->errmess));		warn_user("WimpError", error->errmess);		return;	}	/* open full size */	state.w = history_window;	error = xwimp_get_window_state(&state);	if (error) {		LOG(("xwimp_get_window_state: 0x%x: %s",				error->errnum, error->errmess));		warn_user("WimpError", error->errmess);		return;	}	state.visible.x0 = 0;	state.visible.y0 = 0;	state.visible.x1 = width;	state.visible.y1 = height;	state.next = wimp_HIDDEN;	error = xwimp_open_window(PTR_WIMP_OPEN(&state));	if (error) {		LOG(("xwimp_open_window: 0x%x: %s",				error->errnum, error->errmess));		warn_user("WimpError", error->errmess);		return;	}	ro_gui_dialog_open_persistent(bw->window->window, history_window,			at_pointer);}

bool save_as_draw(hlcache_handle *h, const char *path){	pencil_code code;	char *drawfile_buffer;	size_t drawfile_size;	os_error *error;	ro_save_draw_diagram = pencil_create();	if (!ro_save_draw_diagram) {		warn_user("NoMemory", 0);		return false;	}	ro_save_draw_width = content_get_width(h);	ro_save_draw_height = content_get_height(h);	plot = ro_save_draw_plotters;	if (!content_redraw(h, 0, -ro_save_draw_height,			ro_save_draw_width, ro_save_draw_height,			INT_MIN, INT_MIN, INT_MAX, INT_MAX,			1,			0xFFFFFF))	{		pencil_free(ro_save_draw_diagram);		return false;	}	/*pencil_dump(ro_save_draw_diagram);*/	code = pencil_save_drawfile(ro_save_draw_diagram, "NetSurf",			&drawfile_buffer, &drawfile_size);	if (code != pencil_OK) {		warn_user("SaveError", 0);		pencil_free(ro_save_draw_diagram);		return false;	}	assert(drawfile_buffer);	error = xosfile_save_stamped(path, osfile_TYPE_DRAW,			(byte *) drawfile_buffer, 			(byte *) drawfile_buffer + drawfile_size);	if (error) {		LOG(("xosfile_save_stamped failed: 0x%x: %s",				error->errnum, error->errmess));		warn_user("SaveError", error->errmess);		pencil_free(ro_save_draw_diagram);		return false;	}	pencil_free(ro_save_draw_diagram);	return true;}

/** * Save stylesheets imported by a CONTENT_CSS. * * /param imports  Array of imports * /param count    Number of imports in list * /param path     Path to save to * /return  true on success, false on error and error reported */bool save_imported_sheets(struct nscss_import *imports, uint32_t count, 		const char *path, struct save_complete_entry **list){	char filename[256];	unsigned int j;	char *source;	int source_len;	bool res;	for (j = 0; j != count; j++) {		hlcache_handle *css = imports[j].c;		const char *css_data;		unsigned long css_size;		struct nscss_import *child_imports;		uint32_t child_import_count;		if (css == NULL)			continue;		if (save_complete_list_check(css, *list))			continue;		if (!save_complete_list_add(css, list)) {			warn_user("NoMemory", 0);			return false;		}		child_imports = nscss_get_imports(css, &child_import_count);		if (!save_imported_sheets(child_imports, child_import_count, 				path, list))			return false;		snprintf(filename, sizeof filename, "%p", css);		css_data = content_get_source_data(css, &css_size);		source = rewrite_stylesheet_urls(css_data, css_size, 				&source_len, content_get_url(css), 				*list);		if (!source) {			warn_user("NoMemory", 0);			return false;		}		res = save_complete_gui_save(path, filename, source_len,				source, CONTENT_CSS);		free(source);		if (res == false)			return false;	}	return true;}

nserror theme_install_callback(hlcache_handle *handle,		const hlcache_event *event, void *pw){	char buffer[256];	int author_indent = 0;	switch (event->type) {	case CONTENT_MSG_DONE:	{		const char *source_data;		unsigned long source_size;		theme_install_content = handle;		source_data = content_get_source_data(handle, &source_size);		if (!theme_install_read(source_data, source_size)) {			warn_user("ThemeInvalid", 0);			theme_install_close(dialog_theme_install);			break;		}		/* remove '
C++ warnf函数代码示例
C++ warn_print函数代码示例