int command(
char *nBI,
char *command,
char *message,
int size)
{
mxml_node_t *xDoc;
mxml_node_t *messageNode;
mxml_node_t *innerNode[2];
xDoc = mxmlNewXML("1.0");
messageNode = mxmlNewElement(xDoc, "message");
innerNode[0] = mxmlNewElement(messageNode, "type");
mxmlNewText(innerNode[0], 0, "Command");
innerNode[1] = mxmlNewElement(messageNode, "Command");
mxmlNewText(innerNode[1], 0, command);
mxmlSaveString (xDoc, message, size, MXML_NO_CALLBACK);
mxmlDelete(xDoc);
return 0;
}
int logInMessage(
char *nBI,
char *name,
char *hostName,
char *message,
int size)
{
mxml_node_t *xDoc;
mxml_node_t *messageNode;
mxml_node_t *innerNode[4];
xDoc = mxmlNewXML("1.0");
messageNode = mxmlNewElement(xDoc, "message");
innerNode[0] = mxmlNewElement(messageNode, "type");
mxmlNewText(innerNode[0], 0, "Login");
innerNode[1] = mxmlNewElement(messageNode, "nBI");
mxmlNewText(innerNode[1], 0, nBi);
innerNode[2] = mxmlNewElement(messageNode, "name");
mxmlNewText(innerNode[2], 0, name);
innerNode[3] = mxmlNewElement(messageNode, "hostName");
mxmlNewText(innerNode[3], 0, hostName);
mxmlSaveString (xDoc, message, size, MXML_NO_CALLBACK);
mxmlDelete(xDoc);
return 0;
}
/**
* Extracts the device XML description given its internal structure
*
* @param device_to_extract The Device that we want to extract
*
* @return The XML description of the device or NULL if failed
*/
char *
extract_device_xml(Device *device_to_extract)
{
if(device_is_in_xml_file (device_to_extract) == HPD_NO)
return NULL;
mxml_node_t *xml;
xml = mxmlNewXML("1.0");
mxml_node_t *new_device;
new_device = mxmlNewElement(xml, "device");
if(device_to_extract->description != NULL) mxmlElementSetAttr(new_device, "desc", device_to_extract->description);
if(device_to_extract->ID != NULL) mxmlElementSetAttr(new_device, "id", device_to_extract->ID);
if(device_to_extract->vendorID != NULL) mxmlElementSetAttr(new_device, "vendorID", device_to_extract->vendorID);
if(device_to_extract->productID != NULL) mxmlElementSetAttr(new_device, "productID", device_to_extract->productID);
if(device_to_extract->version != NULL) mxmlElementSetAttr(new_device, "version", device_to_extract->version);
if(device_to_extract->IP != NULL) mxmlElementSetAttr(new_device, "ip", device_to_extract->IP);
if(device_to_extract->port != NULL) mxmlElementSetAttr(new_device, "port", device_to_extract->port);
if(device_to_extract->location != NULL) mxmlElementSetAttr(new_device, "location", device_to_extract->location);
if(device_to_extract->type != NULL) mxmlElementSetAttr(new_device, "type", device_to_extract->type);
char* return_string = mxmlSaveAllocString(xml, MXML_NO_CALLBACK);
mxmlDelete(xml);
return return_string;
}
void StreamlineSetup::sendCounters() {
mxml_node_t *xml;
mxml_node_t *counters;
xml = mxmlNewXML("1.0");
counters = mxmlNewElement(xml, "counters");
int count = 0;
for (Driver *driver = Driver::getHead(); driver != NULL; driver = driver->getNext()) {
count += driver->writeCounters(counters);
}
mxml_node_t *setup = mxmlNewElement(counters, "setup_warnings");
mxmlNewText(setup, 0, logg.getSetup());
if (count == 0) {
logg.logError("No counters found, this could be because /dev/gator/events can not be read or because perf is not working correctly");
handleException();
}
char* string = mxmlSaveAllocString(xml, mxmlWhitespaceCB);
sendString(string, RESPONSE_XML);
free(string);
mxmlDelete(xml);
}
mxml_node_t* CapturedXML::getTree(bool includeTime) {
mxml_node_t *xml;
mxml_node_t *captured;
mxml_node_t *target;
int x;
xml = mxmlNewXML("1.0");
captured = mxmlNewElement(xml, "captured");
mxmlElementSetAttr(captured, "version", "1");
if (gSessionData->perf.isSetup()) {
mxmlElementSetAttr(captured, "type", "Perf");
}
mxmlElementSetAttrf(captured, "protocol", "%d", PROTOCOL_VERSION);
if (includeTime) { // Send the following only after the capture is complete
if (time(NULL) > 1267000000) { // If the time is reasonable (after Feb 23, 2010)
mxmlElementSetAttrf(captured, "created", "%lu", time(NULL)); // Valid until the year 2038
}
}
target = mxmlNewElement(captured, "target");
mxmlElementSetAttr(target, "name", gSessionData->mCoreName);
mxmlElementSetAttrf(target, "sample_rate", "%d", gSessionData->mSampleRate);
mxmlElementSetAttrf(target, "cores", "%d", gSessionData->mCores);
mxmlElementSetAttrf(target, "cpuid", "0x%x", gSessionData->mMaxCpuId);
if (!gSessionData->mOneShot && (gSessionData->mSampleRate > 0)) {
mxmlElementSetAttr(target, "supports_live", "yes");
}
if (gSessionData->mLocalCapture) {
mxmlElementSetAttr(target, "local_capture", "yes");
}
mxml_node_t *counters = NULL;
for (x = 0; x < MAX_PERFORMANCE_COUNTERS; x++) {
const Counter & counter = gSessionData->mCounters[x];
if (counter.isEnabled()) {
if (counters == NULL) {
counters = mxmlNewElement(captured, "counters");
}
mxml_node_t *const node = mxmlNewElement(counters, "counter");
mxmlElementSetAttrf(node, "key", "0x%x", counter.getKey());
mxmlElementSetAttr(node, "type", counter.getType());
if (counter.getEvent() != -1) {
mxmlElementSetAttrf(node, "event", "0x%x", counter.getEvent());
}
if (counter.getCount() > 0) {
mxmlElementSetAttrf(node, "count", "%d", counter.getCount());
}
if (counter.getCores() > 0) {
mxmlElementSetAttrf(node, "cores", "%d", counter.getCores());
}
}
}
return xml;
}
init_to_server_XML::init_to_server_XML(const string& sessionkey, const vector<string>& ports, const string& minproxy, const string& maxproxy, const string& username, const string& password)
{
mxml_node_t* xml;
mxml_node_t* data;
mxml_node_t* node;
mxml_node_t* updata;
mxml_node_t* lset;
mxml_node_t* prange;
mxml_node_t* login; /*all of these are not necciary, simply cleaner*/
xml = mxmlNewXML("1.0");
data = mxmlNewElement(xml,"bcmessage");
node = mxmlNewElement(data,"vers");
mxmlNewText(node,0,"1");
node = mxmlNewElement(data,"type");
mxmlNewText(node,0,"1");
node = mxmlNewElement(data,"sessionkey");
node = mxmlNewElement(data,"sessionnumchunks");
mxmlNewText(node,0,"0");
updata = mxmlNewElement(data,"message");
lset = mxmlNewElement(updata,"listenset");
for(unsigned int i = 0; i < ports.size(); i ++)
{
node = mxmlNewElement(lset,"port");
mxmlNewText(node,0,ports[i].c_str());
}
prange = mxmlNewElement(updata,"proxyrange");
node = mxmlNewElement(prange,"min");
mxmlNewText(node,0,minproxy.c_str());
node = mxmlNewElement(prange,"max");
mxmlNewText(node,0,maxproxy.c_str());
login = mxmlNewElement(updata,"login");
node = mxmlNewElement(login,"username");
mxmlNewText(node,0,username.c_str());
node = mxmlNewElement(login,"password");
mxmlNewText(node,0,password.c_str());
char buffer[4096]; /*Should never approach this unless you're being stupid; and at that point, you can seg fault yourself.*/
mxmlSaveString(xml,buffer,4069,NULL);
mxmlDelete(xml);
initmsg = string(buffer);
#ifdef CASCADE_DEBUG
cerr << initmsg << endl;;
ofstream f("init_to_server.xml");
f << initmsg;
f.close();
#endif
}
/**
* Extracts the service XML description given its internal structure
*
* @param _service_to_extract The Service that we want to extract
*
* @return The XML description of the service or NULL if failed
*/
char *
extract_service_xml(Service *_service_to_extract)
{
if(service_is_in_xml_file (_service_to_extract) == HPD_NO)
return NULL;
mxml_node_t *xml;
xml = mxmlNewXML("1.0");
mxml_node_t *new_service;
mxml_node_t *new_device;
mxml_node_t *new_parameter;
new_service = mxmlNewElement(xml, "service");
if(_service_to_extract->description != NULL) mxmlElementSetAttr(new_service, "desc", _service_to_extract->description);
if(_service_to_extract->ID != NULL) mxmlElementSetAttr(new_service, "id", _service_to_extract->ID);
mxmlElementSetAttr(new_service, "isActuator", _service_to_extract->isActuator ? "1" : "0");
if(_service_to_extract->value_url != NULL) mxmlElementSetAttr(new_service, "value_url", _service_to_extract->value_url);
if(_service_to_extract->type != NULL) mxmlElementSetAttr(new_service, "type", _service_to_extract->type);
if(_service_to_extract->unit != NULL) mxmlElementSetAttr(new_service, "unit", _service_to_extract->unit);
new_device = mxmlNewElement(new_service, "device");
if(_service_to_extract->device->description != NULL) mxmlElementSetAttr(new_device, "desc", _service_to_extract->device->description);
if(_service_to_extract->device->ID != NULL) mxmlElementSetAttr(new_device, "id", _service_to_extract->device->ID);
if(_service_to_extract->device->vendorID != NULL) mxmlElementSetAttr(new_device, "vendorid", _service_to_extract->device->vendorID);
if(_service_to_extract->device->productID != NULL) mxmlElementSetAttr(new_device, "productid", _service_to_extract->device->productID);
if(_service_to_extract->device->version != NULL) mxmlElementSetAttr(new_device, "version", _service_to_extract->device->version);
if(_service_to_extract->device->IP != NULL) mxmlElementSetAttr(new_device, "ip", _service_to_extract->device->IP);
if(_service_to_extract->device->port != NULL) mxmlElementSetAttr(new_device, "port", _service_to_extract->device->port);
if(_service_to_extract->device->location != NULL) mxmlElementSetAttr(new_device, "location", _service_to_extract->device->location);
if(_service_to_extract->device->type != NULL) mxmlElementSetAttr(new_device, "type", _service_to_extract->device->type);
Parameter *iterator = _service_to_extract->parameter;
if(iterator != NULL)
{
new_parameter = mxmlNewElement(new_service, "parameter");
if(iterator->ID != NULL) mxmlElementSetAttr(new_parameter, "id", iterator->ID);
if(iterator->max != NULL) mxmlElementSetAttr(new_parameter, "max", iterator->max);
if(iterator->min != NULL) mxmlElementSetAttr(new_parameter, "min", iterator->min);
if(iterator->scale != NULL) mxmlElementSetAttr(new_parameter, "scale", iterator->scale);
if(iterator->step != NULL) mxmlElementSetAttr(new_parameter, "step", iterator->step);
if(iterator->type != NULL) mxmlElementSetAttr(new_parameter, "type", iterator->type);
if(iterator->unit != NULL) mxmlElementSetAttr(new_parameter, "unit", iterator->unit);
if(iterator->values != NULL) mxmlElementSetAttr(new_parameter, "values", iterator->values);
}
char* return_string = mxmlSaveAllocString(xml, MXML_NO_CALLBACK);
mxmlDelete(xml);
return return_string;
}
static bool game_data_init(const char *fname, bool from_update)
{
static bool initialized = false;
if(initialized){
return true;
}
if(!decrypt_file(fname, from_update)){
printf("Error decrypting file!\n");
return false;
}
xml = mxmlNewXML("1.0");
tree = mxmlLoadString(xml, decoded, MXML_TEXT_CALLBACK);
return (tree != NULL);
}
const char* set_keyvalue(const char* xmlstr, const char* catelog_name, const char* key_name, const char* value)
{
if ((!catelog_name) || (!key_name) || (!value))
{
DbgPrint("get_keyvalue input parameter error");
return (NULL);
}
mxml_node_t *xml;
if (xmlstr == NULL)
{
xml = mxmlNewXML("1.0");
}
else
{
xml = mxmlLoadString(NULL, xmlstr, MXML_TEXT_CALLBACK);
}
if (xml == NULL)
{
DbgPrint("xml load err: %s", xmlstr);
return (NULL);
}
mxml_node_t *catelog = mxmlFindElement(xml, xml, catelog_name, NULL, NULL, MXML_DESCEND);
if (catelog == NULL)
{
catelog = mxmlNewElement(xml, catelog_name);
}
mxml_node_t *node = mxmlFindElement(catelog,catelog,key_name,NULL,NULL,MXML_DESCEND);
if (node)
{
mxmlSetText(node, 0, value);
}
else
{
node = mxmlNewElement(catelog, key_name);
mxmlNewText(node, 0, value);
}
mxmlSetWrapMargin(2);
char* system_xmlstr = strdup_tls(mxmlSaveAllocString(xml, MXML_TEXT_CALLBACK));
mxmlDelete(xml);
return (system_xmlstr);
}
/**
* Returns an internal char* of a value under the form of :
* "<?xml version="1.0" encoding="UTF-8"?><value timestamp = xxxxxx >desired_value</value>"
*
* @param value The string of the value desired
*
* @return Returns the char* corresponding
*/
char *
get_xml_value(char* value)
{
mxml_node_t *xml;
mxml_node_t *xml_value;
xml = mxmlNewXML("1.0");
xml_value = mxmlNewElement(xml, "value");
mxmlElementSetAttr(xml_value, "timestamp", timestamp());
mxmlNewText(xml_value, 0, value);
char* return_value = mxmlSaveAllocString(xml, MXML_NO_CALLBACK);
mxmlDelete(xml);
return return_value;
}
int xmldb_open(void)
{
FILE * fp;
mxml_node_t * version;
fp = fopen(XML_DB, "r"); //打开文件
if (fp != NULL) { //文件不存在 创建
mxml_node_t = mxmlNewXML("1.0");
if (xml_root == NULL) {
log_error(LOG_ERROR, "mxmlNewXML");
return -1;
}
version = mxmlNewElement(xml_root, VERSION);
if (version == NULL) {
log_error(LOG_ERROR, "mxmlNewElement");
return -1;
}
version = mxmlNewElement(xml_root, "0.00");
if (version == NULL) {
log_error(LOG_ERROR, "mxmlNewElement");
return -1;
}
} else if (fp == NULL && errno == EEXIST) { //文件存在 读取
xml_root = mxmlLoadFile(NULL, fp, MXML_TEXT_CALLBACK); //已子节点载入 全部使用字符串
if (xml_root == NULL) {
log_error(LOG_ERROR, "mxmlLoadFile");
return -1;
}
/*
cmd = mxmlNewElement(xml_root, CMD_NODE);
if (cmd == NULL) {
log_error(LOG_ERROR, "mxmlNewElement");
return -1;
}
*/
} else {
log_error(LOG_ERROR, "xml open");
return -1;
}
return 0;
}
static int
preparePalData (gamePalette pals[], int palCount)
{
xml = mxmlNewXML("1.0");
mxmlSetWrapMargin(0); // disable line wrapping
data = mxmlNewElement(xml, "palette");
mxmlElementSetAttr(data, "app", APPNAME);
mxmlElementSetAttr(data, "version", APPVERSION);
for (int i=0; i<palCount; i++)
createXMLPalette(&pals[i], false);
int datasize = mxmlSaveString(xml, (char *)savebuffer, SAVEBUFFERSIZE, XMLSavePalCallback);
mxmlDelete(xml);
return datasize;
}
char *build_complete_multipart_upload_xml(aos_pool_t *p, aos_list_t *bc)
{
char *xml_buff;
char *complete_part_xml;
aos_string_t xml_doc;
mxml_node_t *doc;
mxml_node_t *root_node;
oss_complete_part_content_t *content;
doc = mxmlNewXML("1.0");
root_node = mxmlNewElement(doc, "CompleteMultipartUpload");
aos_list_for_each_entry(content, bc, node) {
mxml_node_t *part_node = mxmlNewElement(root_node, "Part");
mxml_node_t *part_number_node = mxmlNewElement(part_node, "PartNumber");
mxmlNewText(part_number_node, 0, content->part_number.data);
mxml_node_t *etag_node = mxmlNewElement(part_node, "ETag");
mxmlNewText(etag_node, 0, content->etag.data);
}
/**
* Initialization of the services.xml file that will be used
* throughout the whole process
*
* @param name the name of the devicelist
* @param id the id of the devicelist
*
* @return returns HPD_E_SUCCESS if successful
*/
int
init_xml_file(char *name, char *id)
{
create_service_xml_file();
mxml_node_t *devicelist;
service_xml_file->xml_tree = mxmlNewXML("1.0");
devicelist = mxmlNewElement(service_xml_file->xml_tree, "devicelist");
mxmlElementSetAttr(devicelist, "name", name);
mxmlElementSetAttr(devicelist, "id", id);
mxmlElementSetAttr(devicelist, "xmlns:xsi", "http://www.w3.org/2001/XMLSchema-instance");
mxmlElementSetAttr(devicelist, "xsi:noNamespaceSchemaLocation", "http://cs.au.dk/dithus/xml/devicedescription.xsd");
save_xml_tree();
return HPD_E_SUCCESS;
}
static int PrintResult (int result) {
char buffer[8];
sprintf(buffer, "%d", result);
mxml_node_t *xml;
mxml_node_t *data;
mxml_node_t *node;
xml = mxmlNewXML("1.0");
data = mxmlNewElement(xml, "privacymask");
node = mxmlNewElement(data, "res");
mxmlElementSetAttr(node, "ul", buffer);
printf("Content-type: application/xml\n\n");
mxmlSaveFile(xml, stdout, MXML_NO_CALLBACK);
mxmlDelete(xml);
return 0;
}
int save_game(char * path, settings * game_settings) {
FILE * fp;
mxml_node_t * tree;
mxml_node_t * game_node;
mxml_node_t * board_node;
cord c;
char row_name[6] = "row_x";
char row[9] = { 0 };
fp = fopen(path, "w");
if (fp == NULL)
return FALSE;
tree = mxmlNewXML("1.0");
game_node = mxmlNewElement(tree, "game");
mxmlNewInteger(mxmlNewElement(game_node, "game_mode"), game_settings->mode);
mxmlNewOpaque(mxmlNewElement(game_node, "user_color"), color_string(game_settings->color));
mxmlNewOpaque(mxmlNewElement(game_node, "next_turn"), color_string(game_settings->next));
if (game_settings->minimax_depth == BEST_DIFFICULTY)
mxmlNewOpaque(mxmlNewElement(game_node, "user_color"), "best");
else
mxmlNewInteger(mxmlNewElement(game_node, "difficulty"), game_settings->minimax_depth);
board_node = mxmlNewElement(game_node, "board");
for (int y = 8; y > 0; y--) {
for (int x = 0; x < 8; x++) {
c.x = x;
c.y = y - 1;
row[x] = (board_piece(game_settings->board, c) == EMPTY) ? '_' : board_piece(game_settings->board, c);
}
row_name[4] = '0' + y;
mxmlNewOpaque(mxmlNewElement(board_node, row_name), row);
}
mxmlSaveFile(tree, fp, MXML_NO_CALLBACK);
fclose(fp);
mxmlDelete(tree);
return TRUE;
}
void StreamlineSetup::sendCounters() {
mxml_node_t *xml;
mxml_node_t *counters;
xml = mxmlNewXML("1.0");
counters = mxmlNewElement(xml, "counters");
int count = 0;
for (Driver *driver = Driver::getHead(); driver != NULL; driver = driver->getNext()) {
count += driver->writeCounters(counters);
}
if (count == 0) {
logg.logError("No counters found, this could be because /dev/gator/events can not be read or because perf is not working correctly");
handleException();
}
mxml_node_t *setup = mxmlNewElement(counters, "setup_warnings");
mxmlNewText(setup, 0, logg.getSetup());
if (gSessionData.mSharedData->mClustersAccurate) {
for (int cluster = 0; cluster < gSessionData.mSharedData->mClusterCount; ++cluster) {
mxml_node_t *node = mxmlNewElement(counters, "cluster");
mxmlElementSetAttrf(node, "id", "%i", cluster);
mxmlElementSetAttr(node, "name", gSessionData.mSharedData->mClusters[cluster]->getPmncName());
}
for (int cpu = 0; cpu < gSessionData.mCores; ++cpu) {
if (gSessionData.mSharedData->mClusterIds[cpu] >= 0) {
mxml_node_t *node = mxmlNewElement(counters, "cpu");
mxmlElementSetAttrf(node, "id", "%i", cpu);
mxmlElementSetAttrf(node, "cluster", "%i", gSessionData.mSharedData->mClusterIds[cpu]);
}
}
}
char* string = mxmlSaveAllocString(xml, mxmlWhitespaceCB);
mxmlDelete(xml);
sendString(string, RESPONSE_XML);
free(string);
}
static int preparePrefsData() {
xml = mxmlNewXML("1.0");
mxmlSetWrapMargin(0); // disable line wrapping
data = mxmlNewElement(xml, "file");
mxmlElementSetAttr(data, "app", APPNAME);
mxmlElementSetAttr(data, "version", APPVERSION);
createXMLSection("Menu", "Menu Settings");
createXMLSetting("ExitAction", "Exit Action", toStr(XMPlayerCfg.exit_action));
createXMLSetting("language", "Language", toStr(XMPlayerCfg.language));
createXMLSetting("sort_order", "Sort Order", toStr(XMPlayerCfg.sort_order));
int datasize = mxmlSaveString(xml, (char *) savebuffer, SAVEBUFFERSIZE, XMLSaveCallback);
mxmlDelete(xml);
printf("XMPlayerCfg.language : %d\n",XMPlayerCfg.language);
return datasize;
}
int BCF_Write(bcf_t* bcf, const char* filename)
{
FILE *fp;
int i;
mxml_node_t *baroboData, *addresses, *dongles, *iter;
if(filename == NULL) {
filename = bcf->filename;
}
fp = fopen(filename, "w");
if(fp == NULL) {
fprintf(stderr, "Error opening file %s for writing.\n", filename);
return -1;
}
/* Write everything */
bcf->root = mxmlNewXML("1.0");
baroboData = mxmlNewElement(bcf->root, "BaroboData");
addresses = mxmlNewElement(baroboData, "addresses");
mxmlElementSetAttrf(
addresses,
"num",
"%d", bcf->num);
dongles = mxmlNewElement(baroboData, "dongles");
mxmlElementSetAttrf(
dongles,
"num", "%d", bcf->numDongles);
for(i = 0; i < bcf->num; i++) {
iter = mxmlNewElement(addresses, "child");
mxmlNewText(iter, 0, bcf->entries[i]);
}
for(i = 0; i < bcf->numDongles; i++) {
iter = mxmlNewElement(dongles, "dongle");
mxmlNewText(iter, 0, bcf->dongles[i]);
}
mxmlSaveFile(bcf->root, fp, MXML_NO_CALLBACK);
fclose(fp);
return 0;
}
int challengeResponseMessage(
char *challResp,
char *message,
int size)
{
mxml_node_t *xDoc;
mxml_node_t *messageNode;
mxml_node_t *innerNode[2];
xDoc = mxmlNewXML("1.0");
messageNode = mxmlNewElement(xDoc, "message");
innerNode[0] = mxmlNewElement(messageNode, "type");
mxmlNewText(innerNode[0], 0, "ChallengeResponse");
innerNode[1] = mxmlNewElement(messageNode, "ChallengeResponse");
mxmlNewText(innerNode[1], 0, challResp);
mxmlSaveString (xDoc, message, size, MXML_NO_CALLBACK);
mxmlDelete(xDoc);
return 0;
}
int LoadSave_saveRocketXML(const text_t* path, TrackData* trackData)
{
mxml_node_t* xml;
mxml_node_t* tracks;
FILE* fp;
size_t p;
struct sync_data* sync_data = &trackData->syncData;
int* bookmarks = trackData->bookmarks;
xml = mxmlNewXML("1.0");
// save all bookmarks
for (p = 0; p < (size_t)trackData->bookmarkCount; ++p)
{
mxml_node_t* node;
const int bookmark = *bookmarks++;
if (bookmark == 0)
continue;
node = mxmlNewElement(xml, "bookmark");
setElementInt(node, "row", "%d", bookmark);
}
// save groups that are folded
for (p = 0; p < (size_t)trackData->groupCount; ++p)
{
mxml_node_t* node;
Group* group = &trackData->groups[p];
if (!group->folded)
continue;
node = mxmlNewElement(xml, "group");
mxmlElementSetAttr(node, "name", group->name);
}
tracks = mxmlNewElement(xml, "tracks");
mxmlElementSetAttr(tracks, "rows", "10000");
setElementInt(tracks, "startRow", "%d", trackData->startRow);
setElementInt(tracks, "endRow", "%d", trackData->endRow);
setElementInt(tracks, "highlightRowStep", "%d", trackData->highlightRowStep);
for (p = 0; p < sync_data->num_tracks; ++p)
{
int i;
const struct sync_track* t = sync_data->tracks[p];
mxml_node_t* track = mxmlNewElement(tracks, "track");
mxmlElementSetAttr(track, "name", t->name);
mxmlElementSetAttr(track, "folded", trackData->tracks[p].folded ? "1" : "0");
setElementInt(track, "color", "%08x", trackData->tracks[p].color);
for (i = 0; i < (int)t->num_keys; ++i)
{
mxml_node_t* key = mxmlNewElement(track, "key");
setElementInt(key, "row", "%d", (int)t->keys[i].row);
setElementFloat(key, "value", t->keys[i].value);
setElementInt(key, "interpolation", "%d", (int)t->keys[i].type);
}
}
#if defined(_WIN32)
_wfopen_s(&fp, path, L"wt");
#else
fp = fopen(path, "wt");
#endif
mxmlSaveFile(xml, fp, whitespaceCallback);
fclose(fp);
return true;
}
int main (int argc, char *argv[])
{
FILE *fp; /*File to write*/
mxml_node_t *xml;
mxml_node_t *graph;
mxml_node_t *graph_id;
mxml_node_t *vertices_list;
mxml_node_t *edges_list;
mxml_node_t *vertices;
mxml_node_t *vertex;
mxml_node_t *vertex_id;
mxml_node_t *outedges;
mxml_node_t *inedges;
mxml_node_t *Vertex_attributes;
mxml_node_t *vertex_attribute;
mxml_node_t *vertex_attribute_name;
mxml_node_t *vertex_attribute_value;
mxml_node_t *vertex_attribute_value_type;
mxml_node_t *edges;
mxml_node_t *edge;
mxml_node_t *edge_id;
mxml_node_t *startV;
mxml_node_t *endV;
mxml_node_t *edge_attributes;
mxml_node_t *edge_attribute;
mxml_node_t *edge_attribute_name;
mxml_node_t *edge_attribute_value;
mxml_node_t *edge_attribute_value_type;
xml = mxmlNewXML("1.0");
graph = mxmlNewElement(xml, "graph");
graph_id = mxmlNewElement(graph, "graph_id");
mxmlNewText(graph_id, 1, g->id);
vertices_list = mxmlNewElement(graph, "vertices_list");
mxmlNewText(vertices_list, 1, g->vertexIdList);
edges_list = mxmlNewElement(graph, "edges_list");
mxmlNewText(edges_list, 1, g->edgeIdList);
vertices = mxmlNewElement(graph, "vertices");
GList* listV=NULL;
GList* listE=NULL;
int lv = g_list_length(g->vertexIdList);
int n = 0;
for(n; n<lv; n++)
{
VertexType* v = g_list_nth_data(listV,n);
vertex = mxmlNewElement(vertices, "vertex");
vertex_id=mxmlNewElemet(vertex,"vertex_id");
mxmlNewText(vertex_id, 1, v->id);
outedges = mxmlNewElement(vertex,"outedges");
mxmlNewText(outedges, 1, v->outedges);
inedges = mxmlNewElement(vertex,"inedges");
mxmlNewText(inedges, 1, v->inedges);
vertex_attributes = mxmlNewElement(vertex,"vertex_attributes");
vertex_attribute = mxmlNewElement(vertex_attributes,"vertex_attribute");
GList* v_attr=g_hash_table_get_keys(v->attributes);
int a=g_list_length(v);
int x=0;
for(x;x<a;x++)
{
vertex_attribute_name=mxmlNewElement(vertex_attribute,"vertex_attribute_name");
mxmlNewText(vertex_attribute_name, 1,g_list_nth_data(v_attr,x));
vertex_attribute_name=mxmlNewElement(vertex_attribute, "vertex_attribute_value");
mxmlNewElement(vertex_attribute_value, 1, vertex_get_attribute_value(v, g_list_nth_data(v_attr,x)));
}
}
int le = g_list_length(g->edgeIdList);
int m=0;
for(m; m<le; m++)
{
EdgeType* e= g_list_nth_data(listE,m);
edge =mxmlNewElement(edges,"edge");
edge_id=mxmlNewElement(edge, "edge_id");
mxmlNewText(edge_id,1,e->id);
startV = mxmlNewElement(edge, "startV");
mxmlNewText(startV,1,e->start);
endV = mxmlNewElement(edge,"endV");
mxmlNewText(endV,1,e->end);
edge_attributes = mxmlNewElement(edge, "edge_attributes");
edge_attribute = mxmlNewElement(edge_attributes, "edge_attribute");
GList* e_attr= g_hash_table_get_keys(e->attributes);
int b=g_list_length(e);
int y=0;
for (y; y<b;y++)
{
edge_attribute_name=mxmlNewElement(edge_attribute,"edge_attribute_name");
mxmlNewText(edge_attribute_name,1, g_list_nth_data(e_attr,y));
edge_attribute_name=mxmlNewElement(edge_attribute,"edge_attribute_value");
mxmlNewElement(edge_attribute_value,1, vertex_get_attribute_value(e, g_list_nth_data(e_attr,y)));
}
}
fp = fopen("filename.xml", "w");
mxmlSaveFile(xml, fp, MXML_NO_CALLBACK);
fclose(fp);
}
mxml_node_t* CapturedXML::getTree() {
bool perfCounters = false;
mxml_node_t *xml;
mxml_node_t *captured;
mxml_node_t *target;
mxml_node_t *counters;
mxml_node_t *counter;
int x;
for (x=0; x<MAX_PERFORMANCE_COUNTERS; x++) {
if (gSessionData->mPerfCounterEnabled[x]) {
perfCounters = true;
break;
}
}
xml = mxmlNewXML("1.0");
captured = mxmlNewElement(xml, "captured");
mxmlElementSetAttr(captured, "version", "1");
mxmlElementSetAttrf(captured, "protocol", "%d", PROTOCOL_VERSION);
if (gSessionData->mBytes > 0) { // Send the following only after the capture is complete
if (time(NULL) > 1267000000) { // If the time is reasonable (after Feb 23, 2010)
mxmlElementSetAttrf(captured, "created", "%lu", time(NULL)); // Valid until the year 2038
}
mxmlElementSetAttrf(captured, "bytes", "%d", gSessionData->mBytes);
}
target = mxmlNewElement(captured, "target");
mxmlElementSetAttr(target, "name", gSessionData->mCoreName);
mxmlElementSetAttrf(target, "sample_rate", "%d", gSessionData->mSampleRate);
mxmlElementSetAttrf(target, "cores", "%d", gSessionData->mCores);
if (perfCounters) {
counters = mxmlNewElement(captured, "counters");
for (x = 0; x < MAX_PERFORMANCE_COUNTERS; x++) {
if (gSessionData->mPerfCounterEnabled[x]) {
counter = mxmlNewElement(counters, "counter");
mxmlElementSetAttr(counter, "title", gSessionData->mPerfCounterTitle[x]);
mxmlElementSetAttr(counter, "name", gSessionData->mPerfCounterName[x]);
mxmlElementSetAttrf(counter, "color", "0x%08x", gSessionData->mPerfCounterColor[x]);
mxmlElementSetAttrf(counter, "key", "0x%08x", gSessionData->mPerfCounterKey[x]);
mxmlElementSetAttr(counter, "type", gSessionData->mPerfCounterType[x]);
mxmlElementSetAttrf(counter, "event", "0x%08x", gSessionData->mPerfCounterEvent[x]);
if (gSessionData->mPerfCounterPerCPU[x]) {
mxmlElementSetAttr(counter, "per_cpu", "yes");
}
if (strlen(gSessionData->mPerfCounterOperation[x]) > 0) {
mxmlElementSetAttr(counter, "operation", gSessionData->mPerfCounterOperation[x]);
}
if (gSessionData->mPerfCounterCount[x] > 0) {
mxmlElementSetAttrf(counter, "count", "%d", gSessionData->mPerfCounterCount[x]);
}
if (gSessionData->mPerfCounterLevel[x]) {
mxmlElementSetAttr(counter, "level", "yes");
}
if (strlen(gSessionData->mPerfCounterAlias[x]) > 0) {
mxmlElementSetAttr(counter, "alias", gSessionData->mPerfCounterAlias[x]);
}
if (strlen(gSessionData->mPerfCounterDisplay[x]) > 0) {
mxmlElementSetAttr(counter, "display", gSessionData->mPerfCounterDisplay[x]);
}
if (strlen(gSessionData->mPerfCounterUnits[x]) > 0) {
mxmlElementSetAttr(counter, "units", gSessionData->mPerfCounterUnits[x]);
}
if (gSessionData->mPerfCounterAverageSelection[x]) {
mxmlElementSetAttr(counter, "average_selection", "yes");
}
mxmlElementSetAttr(counter, "description", gSessionData->mPerfCounterDescription[x]);
}
}
}
return xml;
}
void parse_brlan(char* filename, char *filenameout)
{
FILE* fp = fopen(filename, "rb");
if(fp == NULL) {
printf("Error! Couldn't open %s!\n", filename);
exit(1);
}
fseek(fp, 0, SEEK_END);
u32 lengthOfFile = ftell(fp);
fseek(fp, 0, SEEK_SET);
u8 data[lengthOfFile];
fread(data, lengthOfFile, 1, fp);
int i, j;
for(i = 0; i < 16; i++)
{
memset(tag_types_list[i], 0, 24);
memset(tag_types_rlmc_list[i], 0, 24);
memset(tag_types_rlvc_list[i], 0, 24);
}
strcpy(tag_types_list[0], "X Translation");
strcpy(tag_types_list[1], "Y Translation");
strcpy(tag_types_list[2], "Z Translation");
strcpy(tag_types_list[3], "X Flip");
strcpy(tag_types_list[4], "Y Flip");
strcpy(tag_types_list[5], "Angle");
strcpy(tag_types_list[6], "X Zoom");
strcpy(tag_types_list[7], "Y Zoom");
strcpy(tag_types_list[8], "Width");
strcpy(tag_types_list[9], "Height");
strcpy(tag_types_list[10], "0x0A");
strcpy(tag_types_list[11], "0x0B");
strcpy(tag_types_list[12], "0x0C");
strcpy(tag_types_list[13], "0x0D");
strcpy(tag_types_list[14], "0x0E");
strcpy(tag_types_list[15], "0x0F");
strcpy(tag_types_rlmc_list[0], "0x00");
strcpy(tag_types_rlmc_list[1], "0x01");
strcpy(tag_types_rlmc_list[2], "0x02");
strcpy(tag_types_rlmc_list[3], "0x03");
strcpy(tag_types_rlmc_list[4], "Blackcolor R");
strcpy(tag_types_rlmc_list[5], "Blackcolor G");
strcpy(tag_types_rlmc_list[6], "Blackcolor B");
strcpy(tag_types_rlmc_list[7], "Blackcolor A");
strcpy(tag_types_rlmc_list[8], "Whitecolor R");
strcpy(tag_types_rlmc_list[9], "Whitecolor G");
strcpy(tag_types_rlmc_list[10], "Whitecolor B");
strcpy(tag_types_rlmc_list[11], "Whitecolor A");
strcpy(tag_types_rlmc_list[12], "0x0C");
strcpy(tag_types_rlmc_list[13], "0x0D");
strcpy(tag_types_rlmc_list[14], "0x0E");
strcpy(tag_types_rlmc_list[15], "0x0F");
strcpy(tag_types_rlvc_list[0], "Top Left R");
strcpy(tag_types_rlvc_list[1], "Top Left G");
strcpy(tag_types_rlvc_list[2], "Top Left B");
strcpy(tag_types_rlvc_list[3], "Top Left A");
strcpy(tag_types_rlvc_list[4], "Top Right R");
strcpy(tag_types_rlvc_list[5], "Top Right G");
strcpy(tag_types_rlvc_list[6], "Top Right B");
strcpy(tag_types_rlvc_list[7], "Top Right A");
strcpy(tag_types_rlvc_list[8], "Bottom Left R");
strcpy(tag_types_rlvc_list[9], "Bottom Left G");
strcpy(tag_types_rlvc_list[10], "Bottom Left B");
strcpy(tag_types_rlvc_list[11], "Bottom Left A");
strcpy(tag_types_rlvc_list[12], "Bottom Right R");
strcpy(tag_types_rlvc_list[13], "Bottom Right G");
strcpy(tag_types_rlvc_list[14], "Bottom Right B");
strcpy(tag_types_rlvc_list[15], "Bottom Right A");
BRLAN_fileoffset = 0;
brlan_header header;
BRLAN_ReadDataFromMemoryX(&header, data, sizeof(brlan_header));
BRLAN_fileoffset = short_swap_bytes(header.pai1_offset);
brlan_pai1_universal universal;
BRLAN_ReadDataFromMemoryX(&universal, data, sizeof(brlan_pai1_universal));
int pai1_header_type;
brlan_pai1_header_type1 pai1_header1;
brlan_pai1_header_type2 pai1_header2;
brlan_pai1_header_type2 pai1_header;
if((be32(universal.flags) & (1 << 25)) >= 1) {
pai1_header_type = 2;
BRLAN_ReadDataFromMemory(&pai1_header2, data, sizeof(brlan_pai1_header_type2));
} else {
pai1_header_type = 1;
BRLAN_ReadDataFromMemory(&pai1_header1, data, sizeof(brlan_pai1_header_type1));
}
CreateGlobal_pai1(&pai1_header, pai1_header1, pai1_header2, pai1_header_type);
FILE *xmlFile;
xmlFile = fopen(filenameout, "w");
mxml_node_t *xml;
mxml_node_t *xmlan;
xml = mxmlNewXML("1.0");
xmlan = mxmlNewElement(xml, "xmlan");
mxmlElementSetAttrf(xmlan, "version", "%d.%d.%d%s", BENZIN_VERSION_MAJOR, BENZIN_VERSION_MINOR, BENZIN_VERSION_BUILD, BENZIN_VERSION_OTHER);
mxmlElementSetAttrf(xmlan, "framesize", "%lu", (long unsigned int)short_swap_bytes(pai1_header.framesize));
mxmlElementSetAttrf(xmlan, "flags", "%02x", pai1_header.flags);
int timgs = short_swap_bytes(pai1_header.num_timgs);
BRLAN_fileoffset = short_swap_bytes(header.pai1_offset) + sizeof(brlan_pai1_header_type1);
if ( pai1_header_type == 2 ) BRLAN_fileoffset += 4;
int tableoff = BRLAN_fileoffset;
int currtableoff = BRLAN_fileoffset;
mxml_node_t *timg;
for( i = 0; i < timgs; i++) {
u32 curr_timg_off = 0;
BRLAN_ReadDataFromMemory(&curr_timg_off, data, 4);
char timgname[256];
memset(timgname, 0, 256);
int z = tableoff + be32(curr_timg_off);
for( j = 0; data[z] != 0; timgname[j++] = data[z], z++);
{
timg = mxmlNewElement(xmlan, "timg");
mxmlElementSetAttrf(timg, "name", "%s", timgname);
}
currtableoff += 4;
}
int tagcount = short_swap_bytes(pai1_header.num_entries);
u32 taglocations[tagcount];
BRLAN_fileoffset = be32(pai1_header.entry_offset) + short_swap_bytes(header.pai1_offset);
BRLAN_ReadDataFromMemory(taglocations, data, tagcount * sizeof(u32));
for( i = 0; i < tagcount; i++) {
brlan_entry brlanEntry;
tag_header tagHeader;
BRLAN_fileoffset = be32(taglocations[i]) + short_swap_bytes(header.pai1_offset);
u32 brlanEntryOffset = BRLAN_fileoffset;
BRLAN_ReadDataFromMemory(&brlanEntry, data, sizeof(brlan_entry));
mxml_node_t *pane;
pane = mxmlNewElement(xmlan, "pane"); mxmlElementSetAttrf(pane, "name", "%s", brlanEntry.name); mxmlElementSetAttrf(pane, "type", "%u", brlanEntry.is_material);
u32 entrylocations[brlanEntry.num_tags];
BRLAN_ReadDataFromMemory(entrylocations, data, brlanEntry.num_tags * sizeof(u32));
for ( j = 0; j < brlanEntry.num_tags; j++)
{
BRLAN_CreateXMLTag(tagHeader, data, brlanEntryOffset + be32(entrylocations[j]), pane);
}
}
mxmlSaveFile(xml, xmlFile, whitespace_cb);
mxmlDelete(xml);
fclose(xmlFile);
fclose(fp);
}
int main_2(int argc, const char * argv[])
{
mxml_node_t * xml; /*<?xml ... ?>*/
mxml_node_t * data; /*<data>*/
mxml_node_t * node; /*<node>*/
mxml_node_t * group; /*group*/
/*xml*/
xml = mxmlNewXML("1.0");
/*data*/
data = mxmlNewElement(xml, "data");
/*3个node*/
node = mxmlNewElement(data, "node");
mxmlNewText(node, 0, "val1");
node = mxmlNewElement(data, "node");
mxmlNewText(node, 0, "val2");
node = mxmlNewElement(data, "node");
mxmlNewText(node, 0, "val3");
/*group*/
group = mxmlNewElement(data, "group");
/*group 下的三个node*/
node = mxmlNewElement(group, "node");
mxmlNewText(node, 0, "val4");
node = mxmlNewElement(group, "node");
mxmlNewText(node, 0, "val5");
node = mxmlNewElement(group, "node");
mxmlNewText(node, 0, "val6");
/*2个node*/
node = mxmlNewElement(data, "node");
mxmlNewText(node, 0, "val7");
node = mxmlNewElement(data, "node");
mxmlNewText(node, 0, "val8");
/*自动折行控制------似乎不顶用！！！！！！*/
mxmlSetWrapMargin(100);/*设置100列折行*/
mxmlSetWrapMargin(0);/*取消自动折行*/
/*保存*/
/*保存到文件*/
FILE * fp;
fp = fopen("/Users/zhangliang/Desktop/Project/C/Mini-XML/Mini-XML/testxml2.xml", "w");
mxmlSaveFile(xml, fp, MXML_NO_CALLBACK);
fclose(fp);
/*保存到字符串中*/
char buffer[4096];
char * ptr;
mxmlSaveString(xml, buffer, sizeof(buffer), MXML_NO_CALLBACK);
ptr = mxmlSaveAllocString(xml, MXML_NO_CALLBACK);
printf("buffer: %s\n", buffer);
printf("alloc : %s\n", ptr);
free(ptr);
return 0;
}
static int
preparePrefsData ()
{
xml = mxmlNewXML("1.0");
mxmlSetWrapMargin(0); // disable line wrapping
data = mxmlNewElement(xml, "file");
mxmlElementSetAttr(data, "app", APPNAME);
mxmlElementSetAttr(data, "version", APPVERSION);
createXMLSection("File", "File Settings");
createXMLSetting("AutoLoad", "Auto Load", toStr(GCSettings.AutoLoad));
createXMLSetting("AutoSave", "Auto Save", toStr(GCSettings.AutoSave));
createXMLSetting("LoadMethod", "Load Method", toStr(GCSettings.LoadMethod));
createXMLSetting("SaveMethod", "Save Method", toStr(GCSettings.SaveMethod));
createXMLSetting("LoadFolder", "Load Folder", GCSettings.LoadFolder);
createXMLSetting("LastFileLoaded", "Last File Loaded", GCSettings.LastFileLoaded);
createXMLSetting("SaveFolder", "Save Folder", GCSettings.SaveFolder);
createXMLSetting("AppendAuto", "Append Auto to .SAV Files", toStr(GCSettings.AppendAuto));
//createXMLSetting("CheatFolder", "Cheats Folder", GCSettings.CheatFolder);
createXMLSetting("ScreenshotsFolder", "Screenshots Folder", GCSettings.ScreenshotsFolder);
createXMLSetting("BorderFolder", "SGB Borders Folder", GCSettings.BorderFolder);
createXMLSetting("CoverFolder", "Covers Folder", GCSettings.CoverFolder);
createXMLSetting("ArtworkFolder", "Artworks Folder", GCSettings.ArtworkFolder);
createXMLSetting("ImageFolder", "Image Folder", GCSettings.ImageFolder);
createXMLSection("Network", "Network Settings");
createXMLSetting("smbip", "Share Computer IP", GCSettings.smbip);
createXMLSetting("smbshare", "Share Name", GCSettings.smbshare);
createXMLSetting("smbuser", "Share Username", GCSettings.smbuser);
createXMLSetting("smbpwd", "Share Password", GCSettings.smbpwd);
createXMLSection("Video", "Video Settings");
createXMLSetting("videomode", "Video Mode", toStr(GCSettings.videomode));
createXMLSetting("gbaZoomHor", "GBA Horizontal Zoom Level", FtoStr(GCSettings.gbaZoomHor));
createXMLSetting("gbaZoomVert", "GBA Vertical Zoom Level", FtoStr(GCSettings.gbaZoomVert));
createXMLSetting("gbZoomHor", "GB Horizontal Zoom Level", FtoStr(GCSettings.gbZoomHor));
createXMLSetting("gbZoomVert", "GB Vertical Zoom Level", FtoStr(GCSettings.gbZoomVert));
createXMLSetting("gbFixed", "GB Fixed Pixel Ratio", toStr(GCSettings.gbFixed));
createXMLSetting("gbaFixed", "GBA Fixed Pixel Ratio", toStr(GCSettings.gbaFixed));
createXMLSetting("render", "Video Filtering", toStr(GCSettings.render));
createXMLSetting("scaling", "Aspect Ratio Correction", toStr(GCSettings.scaling));
createXMLSetting("xshift", "Horizontal Video Shift", toStr(GCSettings.xshift));
createXMLSetting("yshift", "Vertical Video Shift", toStr(GCSettings.yshift));
createXMLSetting("colorize", "Colorize Mono Gameboy", toStr(GCSettings.colorize));
createXMLSetting("gbaFrameskip", "GBA Frameskip", toStr(GCSettings.gbaFrameskip));
createXMLSection("Menu", "Menu Settings");
createXMLSetting("WiimoteOrientation", "Wiimote Orientation", toStr(GCSettings.WiimoteOrientation));
createXMLSetting("ExitAction", "Exit Action", toStr(GCSettings.ExitAction));
createXMLSetting("MusicVolume", "Music Volume", toStr(GCSettings.MusicVolume));
createXMLSetting("SFXVolume", "Sound Effects Volume", toStr(GCSettings.SFXVolume));
createXMLSetting("Rumble", "Rumble", toStr(GCSettings.Rumble));
createXMLSetting("language", "Language", toStr(GCSettings.language));
createXMLSetting("PreviewImage", "Preview Image", toStr(GCSettings.PreviewImage));
createXMLSection("Emulation", "Emulation Settings");
createXMLSetting("BasicPalette", "Basic Color Palette for GB", toStr(GCSettings.BasicPalette));
createXMLSection("Controller", "Controller Settings");
createXMLSetting("WiiControls", "Match Wii Game", toStr(GCSettings.WiiControls));
createXMLController(btnmap[CTRLR_GCPAD], "gcpadmap", "GameCube Pad");
createXMLController(btnmap[CTRLR_WIIMOTE], "wmpadmap", "Wiimote");
createXMLController(btnmap[CTRLR_CLASSIC], "ccpadmap", "Classic Controller");
createXMLController(btnmap[CTRLR_NUNCHUK], "ncpadmap", "Nunchuk");
createXMLSection("Emulation", "Emulation Settings");
createXMLSetting("OffsetMinutesUTC", "Offset from UTC (minutes)", toStr(GCSettings.OffsetMinutesUTC));
createXMLSetting("GBHardware", "Hardware (GB/GBC)", toStr(GCSettings.GBHardware));
createXMLSetting("SGBBorder", "Border (GB/GBC)", toStr(GCSettings.SGBBorder));
int datasize = mxmlSaveString(xml, (char *)savebuffer, SAVEBUFFERSIZE, XMLSaveCallback);
mxmlDelete(xml);
return datasize;
}
/**
* @brief This is a savegame function which stores the game in xml-Format.
* @param[in] filename The Filename to save to (without extension)
* @param[in] comment Description of the savegame
* @param[out] error On failure an errormessage may be set.
*/
static bool SAV_GameSave (const char *filename, const char *comment, char **error)
{
xmlNode_t *topNode, *node;
char savegame[MAX_OSPATH];
int res;
int requiredBufferLength;
uLongf bufLen;
saveFileHeader_t header;
char dummy[2];
int i;
dateLong_t date;
char message[30];
char timeStampBuffer[32];
if (!CP_IsRunning()) {
*error = _("No campaign active.");
Com_Printf("Error: No campaign active.\n");
return false;
}
if (!B_AtLeastOneExists()) {
*error = _("Nothing to save yet.");
Com_Printf("Error: Nothing to save yet.\n");
return false;
}
Com_MakeTimestamp(timeStampBuffer, sizeof(timeStampBuffer));
Com_sprintf(savegame, sizeof(savegame), "save/%s.%s", filename, SAVEGAME_EXTENSION);
topNode = mxmlNewXML("1.0");
node = XML_AddNode(topNode, SAVE_ROOTNODE);
/* writing Header */
XML_AddInt(node, SAVE_SAVEVERSION, SAVE_FILE_VERSION);
XML_AddString(node, SAVE_COMMENT, comment);
XML_AddString(node, SAVE_UFOVERSION, UFO_VERSION);
XML_AddString(node, SAVE_REALDATE, timeStampBuffer);
CP_DateConvertLong(&ccs.date, &date);
Com_sprintf(message, sizeof(message), _("%i %s %02i"),
date.year, Date_GetMonthName(date.month - 1), date.day);
XML_AddString(node, SAVE_GAMEDATE, message);
/* working through all subsystems. perhaps we should redesign it, order is not important anymore */
Com_Printf("Calling subsystems\n");
for (i = 0; i < saveSubsystemsAmount; i++) {
if (!saveSubsystems[i].save(node))
Com_Printf("...subsystem '%s' failed to save the data\n", saveSubsystems[i].name);
else
Com_Printf("...subsystem '%s' - saved\n", saveSubsystems[i].name);
}
/* calculate the needed buffer size */
OBJZERO(header);
header.compressed = LittleLong(save_compressed->integer);
header.version = LittleLong(SAVE_FILE_VERSION);
header.subsystems = LittleLong(saveSubsystemsAmount);
Q_strncpyz(header.name, comment, sizeof(header.name));
Q_strncpyz(header.gameVersion, UFO_VERSION, sizeof(header.gameVersion));
CP_DateConvertLong(&ccs.date, &date);
Com_sprintf(header.gameDate, sizeof(header.gameDate), _("%i %s %02i"),
date.year, Date_GetMonthName(date.month - 1), date.day);
Q_strncpyz(header.realDate, timeStampBuffer, sizeof(header.realDate));
requiredBufferLength = mxmlSaveString(topNode, dummy, 2, MXML_NO_CALLBACK);
header.xmlSize = LittleLong(requiredBufferLength);
byte* const buf = Mem_PoolAllocTypeN(byte, requiredBufferLength + 1, cp_campaignPool);
if (!buf) {
mxmlDelete(topNode);
*error = _("Could not allocate enough memory to save this game");
Com_Printf("Error: Could not allocate enough memory to save this game\n");
return false;
}
res = mxmlSaveString(topNode, (char*)buf, requiredBufferLength + 1, MXML_NO_CALLBACK);
mxmlDelete(topNode);
Com_Printf("XML Written to buffer (%d Bytes)\n", res);
if (header.compressed)
bufLen = compressBound(requiredBufferLength);
else
bufLen = requiredBufferLength;
byte* const fbuf = Mem_PoolAllocTypeN(byte, bufLen + sizeof(header), cp_campaignPool);
memcpy(fbuf, &header, sizeof(header));
if (header.compressed) {
res = compress(fbuf + sizeof(header), &bufLen, buf, requiredBufferLength);
Mem_Free(buf);
if (res != Z_OK) {
Mem_Free(fbuf);
*error = _("Memory error compressing save-game data - set save_compressed cvar to 0");
Com_Printf("Memory error compressing save-game data (%s) (Error: %i)!\n", comment, res);
return false;
}
} else {
memcpy(fbuf + sizeof(header), buf, requiredBufferLength);
Mem_Free(buf);
}
/* last step - write data */
res = FS_WriteFile(fbuf, bufLen + sizeof(header), savegame);
Mem_Free(fbuf);
return true;
}
static int
preparePrefsData ()
{
xml = mxmlNewXML("1.0");
mxmlSetWrapMargin(0); // disable line wrapping
data = mxmlNewElement(xml, "file");
mxmlElementSetAttr(data, "app", APPNAME);
mxmlElementSetAttr(data, "version", APPVERSION);
createXMLSection("File", "File Settings");
createXMLSetting("AutoLoad", "Auto Load", toStr(GCSettings.AutoLoad));
createXMLSetting("AutoSave", "Auto Save", toStr(GCSettings.AutoSave));
createXMLSetting("LoadMethod", "Load Method", toStr(GCSettings.LoadMethod));
createXMLSetting("SaveMethod", "Save Method", toStr(GCSettings.SaveMethod));
createXMLSetting("LoadFolder", "Load Folder", GCSettings.LoadFolder);
createXMLSetting("SaveFolder", "Save Folder", GCSettings.SaveFolder);
createXMLSetting("CheatFolder", "Cheats Folder", GCSettings.CheatFolder);
createXMLSetting("gamegenie", "Game Genie", toStr(GCSettings.gamegenie));
createXMLSection("Network", "Network Settings");
createXMLSetting("netplayIp", "Netplay IP", GCSettings.netplayIp);
createXMLSetting("netplayPort", "Netplay Port", GCSettings.netplayPort);
createXMLSetting("netplayPwd", "Netplay Password", GCSettings.netplayPwd);
createXMLSetting("netplayNameX", "Netplay Player/Host Name", GCSettings.netplayNameX);
createXMLSetting("netplayNameY", "Netplay Player Name", GCSettings.netplayNameY);
createXMLSetting("netplayNameZ", "Netplay Player Name", GCSettings.netplayNameZ);
createXMLSetting("smbip", "Share Computer IP", GCSettings.smbip);
createXMLSetting("smbshare", "Share Name", GCSettings.smbshare);
createXMLSetting("smbuser", "Share Username", GCSettings.smbuser);
createXMLSetting("smbpwd", "Share Password", GCSettings.smbpwd);
createXMLSection("Video", "Video Settings");
createXMLSetting("videomode", "Video Mode", toStr(GCSettings.videomode));
createXMLSetting("currpal", "Palette", toStr(GCSettings.currpal));
createXMLSetting("timing", "Timing", toStr(GCSettings.timing));
createXMLSetting("spritelimit", "Sprite Limit", toStr(GCSettings.spritelimit));
createXMLSetting("zoomHor", "Horizontal Zoom Level", FtoStr(GCSettings.zoomHor));
createXMLSetting("zoomVert", "Vertical Zoom Level", FtoStr(GCSettings.zoomVert));
createXMLSetting("render", "Video Filtering", toStr(GCSettings.render));
createXMLSetting("widescreen", "Aspect Ratio Correction", toStr(GCSettings.widescreen));
createXMLSetting("hideoverscan", "Video Cropping", toStr(GCSettings.hideoverscan));
createXMLSetting("xshift", "Horizontal Video Shift", toStr(GCSettings.xshift));
createXMLSetting("yshift", "Vertical Video Shift", toStr(GCSettings.yshift));
createXMLSection("Menu", "Menu Settings");
createXMLSetting("WiimoteOrientation", "Wiimote Orientation", toStr(GCSettings.WiimoteOrientation));
createXMLSetting("ExitAction", "Exit Action", toStr(GCSettings.ExitAction));
createXMLSetting("MusicVolume", "Music Volume", toStr(GCSettings.MusicVolume));
createXMLSetting("SFXVolume", "Sound Effects Volume", toStr(GCSettings.SFXVolume));
createXMLSetting("Rumble", "Rumble", toStr(GCSettings.Rumble));
createXMLSetting("language", "Language", toStr(GCSettings.language));
createXMLSection("Controller", "Controller Settings");
createXMLSetting("Controller", "Controller", toStr(GCSettings.Controller));
createXMLSetting("crosshair", "Zapper Crosshair", toStr(GCSettings.crosshair));
createXMLController(btnmap[CTRL_PAD][CTRLR_GCPAD], "btnmap_pad_gcpad", "NES Pad - GameCube Controller");
createXMLController(btnmap[CTRL_PAD][CTRLR_WIIMOTE], "btnmap_pad_wiimote", "NES Pad - Wiimote");
createXMLController(btnmap[CTRL_PAD][CTRLR_CLASSIC], "btnmap_pad_classic", "NES Pad - Classic Controller");
createXMLController(btnmap[CTRL_PAD][CTRLR_NUNCHUK], "btnmap_pad_nunchuk", "NES Pad - Nunchuk + Wiimote");
createXMLController(btnmap[CTRL_ZAPPER][CTRLR_GCPAD], "btnmap_zapper_gcpad", "Zapper - GameCube Controller");
createXMLController(btnmap[CTRL_ZAPPER][CTRLR_WIIMOTE], "btnmap_zapper_wiimote", "Zapper - Wiimote");
int datasize = mxmlSaveString(xml, (char *)savebuffer, SAVEBUFFERSIZE, XMLSaveCallback);
mxmlDelete(xml);
return datasize;
}
void game_save(game* p_game, char* file)
{
FILE *fp = NULL;
fp = fopen(file, "w");
element* p_browse;
char buffer[10];
mxml_node_t *mxml_xml;
mxml_node_t *mxml_game;
mxml_node_t *mxml_unit;
mxml_node_t *mxml_vars;
mxml_node_t *mxml_i;
mxml_xml = mxmlNewXML("1.0");
mxml_game = mxmlNewElement(mxml_xml, "game");
mxml_unit = mxmlNewElement(mxml_game, "unit");
mxmlElementSetAttr(mxml_unit, "src", "./res/entities/units/mana.xml");
mxml_i = mxmlNewElement(mxml_unit, "location");
char* attr_file = calloc(strlen("./res/maps/") + strlen(p_game->context) + 1, sizeof(char));
strcpy(attr_file, "./res/maps/");
strcat(attr_file, p_game->context);
mxmlElementSetAttr(mxml_i, "file", attr_file);
mxmlElementSetAttr(mxml_i, "name", map_get_current(p_game->p_map, p_game->cur_map)->name);
free(attr_file);
sprintf(buffer, "%d", p_game->p_unit->p_sprite->x);
mxmlElementSetAttr(mxml_i, "x", buffer);
sprintf(buffer, "%d", p_game->p_unit->p_sprite->y);
mxmlElementSetAttr(mxml_i, "y", buffer);
mxml_i = mxmlNewElement(mxml_unit, "HP");
mxmlNewInteger(mxml_i, p_game->p_unit->HP);
mxml_i = mxmlNewElement(mxml_unit, "MP");
mxmlNewInteger(mxml_i, p_game->p_unit->MP);
mxml_i = mxmlNewElement(mxml_unit, "XP");
mxmlNewInteger(mxml_i, p_game->p_unit->XP);
mxml_i = mxmlNewElement(mxml_unit, "gold");
mxmlNewInteger(mxml_i, p_game->p_unit->gold);
mxml_vars = mxmlNewElement(mxml_game, "vars");
p_browse = p_game->vars;
while(p_browse){
var *temp = (var*)p_browse->data;
mxml_i = mxmlNewElement(mxml_vars, "var");
mxmlElementSetAttr(mxml_i, "name", temp->name);
mxmlElementSetAttr(mxml_i, "value", temp->value);
p_browse = p_browse->next;
}
mxmlSaveFile(mxml_xml, fp, MXML_NO_CALLBACK);
mxmlDelete(mxml_xml);
fclose(fp);
}
static int
preparePrefsData ()
{
xml = mxmlNewXML("1.0");
mxmlSetWrapMargin(0); // disable line wrapping
data = mxmlNewElement(xml, "file");
mxmlElementSetAttr(data, "app", APPNAME);
mxmlElementSetAttr(data, "version", APPVERSION);
createXMLSection("File", "File Settings");
createXMLSetting("AutoLoad", "Auto Load", toStr(GCSettings.AutoLoad));
createXMLSetting("AutoSave", "Auto Save", toStr(GCSettings.AutoSave));
createXMLSetting("LoadMethod", "Load Method", toStr(GCSettings.LoadMethod));
createXMLSetting("SaveMethod", "Save Method", toStr(GCSettings.SaveMethod));
createXMLSetting("LoadFolder", "Load Folder", GCSettings.LoadFolder);
createXMLSetting("LastFileLoaded", "Last File Loaded", GCSettings.LastFileLoaded);
createXMLSetting("SaveFolder", "Save Folder", GCSettings.SaveFolder);
createXMLSetting("CheatFolder", "Cheats Folder", GCSettings.CheatFolder);
createXMLSetting("ScreenshotsFolder", "Screenshots Folder", GCSettings.ScreenshotsFolder);
createXMLSection("Network", "Network Settings");
createXMLSetting("smbip", "Share Computer IP", GCSettings.smbip);
createXMLSetting("smbshare", "Share Name", GCSettings.smbshare);
createXMLSetting("smbuser", "Share Username", GCSettings.smbuser);
createXMLSetting("smbpwd", "Share Password", GCSettings.smbpwd);
createXMLSection("Video", "Video Settings");
createXMLSetting("videomode", "Video Mode", toStr(GCSettings.videomode));
createXMLSetting("zoomHor", "Horizontal Zoom Level", FtoStr(GCSettings.zoomHor));
createXMLSetting("zoomVert", "Vertical Zoom Level", FtoStr(GCSettings.zoomVert));
createXMLSetting("render", "Video Filtering", toStr(GCSettings.render));
createXMLSetting("widescreen", "Aspect Ratio Correction", toStr(GCSettings.widescreen));
createXMLSetting("crosshair", "Crosshair", toStr(GCSettings.crosshair));
createXMLSetting("FilterMethod", "Filter Method", toStr(GCSettings.FilterMethod));
createXMLSetting("xshift", "Horizontal Video Shift", toStr(GCSettings.xshift));
createXMLSetting("yshift", "Vertical Video Shift", toStr(GCSettings.yshift));
createXMLSection("Menu", "Menu Settings");
createXMLSetting("WiimoteOrientation", "Wiimote Orientation", toStr(GCSettings.WiimoteOrientation));
createXMLSetting("ExitAction", "Exit Action", toStr(GCSettings.ExitAction));
createXMLSetting("MusicVolume", "Music Volume", toStr(GCSettings.MusicVolume));
createXMLSetting("SFXVolume", "Sound Effects Volume", toStr(GCSettings.SFXVolume));
createXMLSetting("Rumble", "Rumble", toStr(GCSettings.Rumble));
createXMLSetting("language", "Language", toStr(GCSettings.language));
createXMLSection("Controller", "Controller Settings");
createXMLSetting("Controller", "Controller", toStr(GCSettings.Controller));
createXMLController(btnmap[CTRL_PAD][CTRLR_GCPAD], "btnmap_pad_gcpad", "SNES Pad - GameCube Controller");
createXMLController(btnmap[CTRL_PAD][CTRLR_WIIMOTE], "btnmap_pad_wiimote", "SNES Pad - Wiimote");
createXMLController(btnmap[CTRL_PAD][CTRLR_CLASSIC], "btnmap_pad_classic", "SNES Pad - Classic Controller");
createXMLController(btnmap[CTRL_PAD][CTRLR_NUNCHUK], "btnmap_pad_nunchuk", "SNES Pad - Nunchuk + Wiimote");
createXMLController(btnmap[CTRL_SCOPE][CTRLR_GCPAD], "btnmap_scope_gcpad", "Superscope - GameCube Controller");
createXMLController(btnmap[CTRL_SCOPE][CTRLR_WIIMOTE], "btnmap_scope_wiimote", "Superscope - Wiimote");
createXMLController(btnmap[CTRL_MOUSE][CTRLR_GCPAD], "btnmap_mouse_gcpad", "Mouse - GameCube Controller");
createXMLController(btnmap[CTRL_MOUSE][CTRLR_WIIMOTE], "btnmap_mouse_wiimote", "Mouse - Wiimote");
createXMLController(btnmap[CTRL_JUST][CTRLR_GCPAD], "btnmap_just_gcpad", "Justifier - GameCube Controller");
createXMLController(btnmap[CTRL_JUST][CTRLR_WIIMOTE], "btnmap_just_wiimote", "Justifier - Wiimote");
int datasize = mxmlSaveString(xml, (char *)savebuffer, SAVEBUFFERSIZE, XMLSaveCallback);
mxmlDelete(xml);
return datasize;
}
