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 );
}