usbloadergx/source/themes/Theme_List.cpp

/***************************************************************************
 * Copyright (C) 2009
 * by USB Loader GX Team
 *
 * This software is provided 'as-is', without any express or implied
 * warranty. In no event will the authors be held liable for any
 * damages arising from the use of this software.
 *
 * Permission is granted to anyone to use this software for any
 * purpose, including commercial applications, and to alter it and
 * redistribute it freely, subject to the following restrictions:
 *
 * 1. The origin of this software must not be misrepresented; you
 * must not claim that you wrote the original software. If you use
 * this software in a product, an acknowledgment in the product
 * documentation would be appreciated but is not required.
 *
 * 2. Altered source versions must be plainly marked as such, and
 * must not be misrepresented as being the original software.
 *
 * 3. This notice may not be removed or altered from any source
 * distribution.
 *
 * Theme_List Class
 * for the USB Loader GX
 ***************************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <gctypes.h>

#include "Theme_List.h"
#include "xml/xml.h"
#include "prompts/PromptWindows.h"

#define stringcompare(text, cmp, pos) strncasecmp((const char*) &text[pos-strlen(cmp)], (const char*) cmp, strlen((const char*) cmp))

static void copyhtmlsting(const char *from, char *outtext, const char *stopat, u32 &cnt)
{
    u32 cnt2 = 0;

    u32 stringlength = strlen(from);

    while ((stringcompare( from, stopat, cnt + strlen( stopat ) ) != 0) && (cnt2 < 1024) && (cnt < stringlength))
    {
        outtext[cnt2] = from[cnt];
        cnt2++;
        cnt++;
    }
    outtext[cnt2] = '\0';
}

Theme_List::Theme_List(const char * url)
{
    Theme = NULL;
    themescount = 0;

    if (!IsNetworkInit())
    {
        themescount = -1;
        return;
    }

    struct block file = downloadfile(url);

    if (!file.data || !file.size)
    {
        themescount = -2;
        return;
    }

    themescount = CountThemes(file.data);
    if (themescount <= 0)
    {
        free(file.data);
        return;
    }

    ParseXML(file.data);

    free(file.data);
}

Theme_List::~Theme_List()
{
    for (int i = 0; i < themescount; i++)
    {
        if (Theme[i].themetitle) delete[] Theme[i].themetitle;
        if (Theme[i].author) delete[] Theme[i].author;
        if (Theme[i].imagelink) delete[] Theme[i].imagelink;
        if (Theme[i].downloadlink) delete[] Theme[i].downloadlink;
        Theme[i].themetitle = NULL;
        Theme[i].author = NULL;
        Theme[i].imagelink = NULL;
        Theme[i].downloadlink = NULL;
    }

    if (Theme) delete[] Theme;
    Theme = NULL;
}

int Theme_List::CountThemes(const u8 * xmlfile)
{
    char tmp[200];
    u32 cnt = 0;
    u32 stringlength = strlen((const char *) xmlfile);
    memset(tmp, 0, sizeof(tmp));

    while (cnt < stringlength)
    {
        if (stringcompare( xmlfile, "<totalthemes>", cnt ) == 0)
        {
            copyhtmlsting((const char *) xmlfile, tmp, ">", cnt);
            break;
        }
        cnt++;
    }
    tmp[cnt + 1] = 0;

    return atoi(tmp);
}

bool Theme_List::ParseXML(const u8 * xmlfile)
{
    char element_text[1024];
    memset(element_text, 0, sizeof(element_text));
    mxml_node_t *nodetree = NULL;
    mxml_node_t *nodedata = NULL;
    mxml_node_t *nodeid = NULL;
    mxml_index_t *nodeindex = NULL;

    nodetree = mxmlLoadString(NULL, (const char *) xmlfile, MXML_OPAQUE_CALLBACK);

    if (nodetree == NULL)
    {
        return false;
    }

    nodedata = mxmlFindElement(nodetree, nodetree, "themes", NULL, NULL, MXML_DESCEND);
    if (nodedata == NULL)
    {
        return false;
    }

    nodeindex = mxmlIndexNew(nodedata, "name", NULL);
    nodeid = mxmlIndexReset(nodeindex);

    Theme = new Theme_Info[themescount];
    memset(Theme, 0, sizeof(Theme));

    for (int i = 0; i < themescount; i++)
    {
        nodeid = mxmlIndexFind(nodeindex, "name", NULL);
        if (nodeid != NULL)
        {
            get_nodetext(nodeid, element_text, sizeof(element_text));
            Theme[i].themetitle = new char[strlen(element_text) + 2];
            snprintf(Theme[i].themetitle, strlen(element_text) + 1, "%s", element_text);

            GetTextFromNode(nodeid, nodedata, (char *) "creator", NULL, NULL, MXML_NO_DESCEND, element_text,
                    sizeof(element_text));
            Theme[i].author = new char[strlen(element_text) + 2];
            snprintf(Theme[i].author, strlen(element_text) + 1, "%s", element_text);

            GetTextFromNode(nodeid, nodedata, (char *) "thumbpath", NULL, NULL, MXML_NO_DESCEND, element_text,
                    sizeof(element_text));
            Theme[i].imagelink = new char[strlen(element_text) + 2];
            snprintf(Theme[i].imagelink, strlen(element_text) + 1, "%s", element_text);

            GetTextFromNode(nodeid, nodedata, (char *) "downloadpath", NULL, NULL, MXML_NO_DESCEND, element_text,
                    sizeof(element_text));
            Theme[i].downloadlink = new char[strlen(element_text) + 2];
            snprintf(Theme[i].downloadlink, strlen(element_text) + 1, "%s", element_text);

            GetTextFromNode(nodeid, nodedata, (char *) "averagerating", NULL, NULL, MXML_NO_DESCEND, element_text,
                    sizeof(element_text));
            Theme[i].rating = atoi(element_text);
        }
    }

    mxmlIndexDelete(nodeindex);
    free(nodetree);
    free(nodedata);
    free(nodeid);
    nodetree = NULL;
    nodedata = NULL;
    nodeid = NULL;
    nodeindex = NULL;

    return true;
}

const char * Theme_List::GetThemeTitle(int ind)
{
    if (ind > themescount || ind < 0 || !Theme || themescount <= 0)
        return NULL;
    else return Theme[ind].themetitle;
}

const char * Theme_List::GetThemeAuthor(int ind)
{
    if (ind > themescount || ind < 0 || !Theme || themescount <= 0)
        return NULL;
    else return Theme[ind].author;
}

const char * Theme_List::GetImageLink(int ind)
{
    if (ind > themescount || ind < 0 || !Theme || themescount <= 0)
        return NULL;
    else return Theme[ind].imagelink;
}

const char * Theme_List::GetDownloadLink(int ind)
{
    if (ind > themescount || ind < 0 || !Theme || themescount <= 0)
        return NULL;
    else return Theme[ind].downloadlink;
}

int Theme_List::GetThemeCount()
{
    return themescount;
}

static int ListCompare(const void *a, const void *b)
{
    Theme_Info *ab = (Theme_Info*) a;
    Theme_Info *bb = (Theme_Info*) b;

    return stricmp((char *) ab->themetitle, (char *) bb->themetitle);
}
void Theme_List::SortList()
{
    qsort(Theme, themescount, sizeof(Theme_Info), ListCompare);
}