profilemanager.cpp

/***************************************************************************
                           profilemanager.cpp
                           -------------------
    begin                : 2004-09-22 12:42
    copyright            : (C) 2004-2005 by Dominik Haumann
    email                : dhaumann@users.sourceforge.net
 ***************************************************************************/

/***************************************************************************
 This program is free software; you can redistribute it and/or
 modify it under the terms of the GNU General Public License
 as published by the Free Software Foundation; either version 2
 of the License, or (at your option) any later version.

 This program is distributed in the hope that it will be useful,
 but WITHOUT ANY WARRANTY; without even the implied warranty of
 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 GNU General Public License for more details.

 You should have received a copy of the GNU General Public License
 along with this program; if not, write to the Free Software
 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 ***************************************************************************/

#include "profilemanager.h"

extern ofstream logFile;

namespace WDS
{

// Statische Variablen initialiseren
CProfile* CProfileManager::m_pCurrentProfile = NULL;

//-------------------------------------------------------------------------
//BEGIN class CProfile
//-------------------------------------------------------------------------
CProfile::CProfile() :
    m_name     (""),
    m_map      (""),
    m_dat      (""),
    m_usephpmap(false),
    m_user     (""),
    m_password (""),
    m_server   (""),
    m_timestamp(1),
    m_fogofwar (false),
    m_dirty    (false),
    m_last_scroll_x(0),
    m_last_scroll_y(0),
    m_last_zoom(1.0f)
{
    m_bookmarks.clear();
    m_recents.clear();
}

CProfile::~CProfile()
{
}

void CProfile::SetName(const wxString& name)
{
    m_name = name;
}

wxString CProfile::GetName() const
{
    return m_name;
}

void CProfile::SetMap(const wxString& strMap )
{
    m_map = strMap;
}

wxString CProfile::GetMap() const
{
    return m_map;
}

void CProfile::SetDat(const wxString& dat)
{
    m_dat = dat;
}

wxString CProfile::GetDat() const
{
    return m_dat;
}

bool CProfile::IsValid() const
{
    return m_map != "";
}

void CProfile::SetUser(const wxString& user)
{
    m_user = user;
}

wxString CProfile::GetUser() const
{
    return m_user;
}

void CProfile::SetPassword(const wxString& pw)
{
    m_password = pw;
}

wxString CProfile::GetPassword() const
{
    return m_password;
}

void CProfile::SetServer(const wxString& server)
{
    m_server = server;
}

wxString CProfile::GetServer() const
{
    return m_server;
}

void CProfile::SetUsePhpmap(bool b_use)
{
    m_usephpmap = b_use;
}

bool CProfile::GetUsePhpmap() const
{
    return m_usephpmap;
}

void CProfile::SetFogOfWar(bool fow)
{
    m_fogofwar = fow;
}

bool CProfile::GetFogOfWar() const
{
    return m_fogofwar;
}

void CProfile::SetTimestamp(int ts)
{
    m_timestamp = ts;
}

int CProfile::GetTimestamp() const
{
    return m_timestamp;
}

void CProfile::SetDirty(bool dirty)
{
    m_dirty = dirty;
}

bool CProfile::GetDirty() const
{
    return m_dirty;
}

GoToArray& CProfile::GetBookmarks()
{
    return m_bookmarks;
}

GoToArray& CProfile::GetRecentGoTos()
{
    return m_recents;
}

void CProfile::AddBookmark( int x, int y, const wxString& comment )
{
    CGoToEntry entry ( x, y, comment );

    GoToArray::iterator it = m_bookmarks.begin();

    for ( ; it != m_bookmarks.end(); it++ ) {
        if ( it->x == x && it->y == y ) {
            m_bookmarks.erase( it );
            break;
        }
    }

    m_bookmarks.push_back( entry );
}

void CProfile::AddRecentGoTo( int x, int y )
{
    CGoToEntry entry ( x, y );

    GoToArray::iterator it = m_recents.begin();

    for ( ; it != m_recents.end(); it++ ) {
        if ( it->x == x && it->y == y ) {
            m_recents.erase( it );
            break;
        }
    }

    m_recents.push_back( entry );

    // limit to 20 entries
    if ( m_recents.size() > 20 ) {
        m_recents.erase( m_recents.begin() );
    }
}

void CProfile::Load( wxFileConfig *pConfig )
{
    SetName( pConfig->Read(wxString("name"), wxString("unknown")) );
    SetMap ( pConfig->Read(wxString("mapfile"), wxString("")) );
    SetDat ( pConfig->Read(wxString("datfile"), wxString("")) );

    SetUsePhpmap( pConfig->Read(wxString("use_phpmap" ), 0L) );
    SetServer   ( pConfig->Read(wxString("server" ), wxString("")) );
    SetUser     ( pConfig->Read(wxString("user" ), wxString("")) );
    SetPassword ( pConfig->Read(wxString("password" ), wxString("")) );
    SetFogOfWar ( pConfig->Read(wxString("fogofwar" ), 1L) );
    SetTimestamp( pConfig->Read(wxString("timestamp" ), 0L) );

    SetLastScrollPosition( pConfig->Read(wxString("last_scroll_x" ), 0L),
                           pConfig->Read(wxString("last_scroll_y" ), 0L) );
    SetLastZoom ( ( (float)pConfig->Read(wxString("last_zoom" ), 100L) ) / 100.0f );

    LoadBookmarks( pConfig );
    LoadRecents( pConfig );
}

void CProfile::Save( wxFileConfig *pConfig )
{
    pConfig->Write( wxString("name"   ), GetName() );
    pConfig->Write( wxString("mapfile"), GetMap() );
    pConfig->Write( wxString("datfile"), GetDat() );

    pConfig->Write( wxString("use_phpmap"), long(GetUsePhpmap()) );
    pConfig->Write( wxString("server"    ), GetServer() );
    pConfig->Write( wxString("user"      ), GetUser() );
    pConfig->Write( wxString("password"  ), GetPassword() );
    pConfig->Write( wxString("fogofwar"  ), GetFogOfWar() );
    pConfig->Write( wxString("timestamp" ), GetTimestamp() );

    pConfig->Write( wxString("last_scroll_x" ), GetLastScrollPositionX() );
    pConfig->Write( wxString("last_scroll_y" ), GetLastScrollPositionY() );

    pConfig->Write( wxString("last_zoom" ), int(GetLastZoom()*100.0) );

    SaveBookmarks( pConfig );
    SaveRecents( pConfig );
}

void CProfile::LoadBookmarks( wxFileConfig *pConfig )
{
    wxString value = pConfig->Read( wxString("bookmarks" ), wxString("") );

    while ( value.length() > 0 ) {
        CGoToEntry entry;

        value.BeforeFirst(':').ToLong( (long int*)&entry.x );
        value = value.AfterFirst(':');
        value.BeforeFirst(';').ToLong( (long int*)&entry.y );
        value = value.AfterFirst(';');
        entry.comment = value.BeforeFirst('\n');
        value = value.AfterFirst('\n');

        m_bookmarks.push_back( entry );
    }
}

void CProfile::LoadRecents( wxFileConfig *pConfig )
{
    wxString value = pConfig->Read( wxString("recents" ), wxString("") );

    while ( value.length() > 0 ) {
        CGoToEntry entry;

        value.BeforeFirst(':').ToLong( (long int*)&entry.x );
        value = value.AfterFirst(':');
        value.BeforeFirst(';').ToLong( (long int*)&entry.y );
        value = value.AfterFirst(';');

        m_recents.push_back( entry );
    }
}

void CProfile::SaveBookmarks( wxFileConfig *pConfig )
{
    wxString tmp;
    GoToArray::iterator it = m_bookmarks.begin();

    while ( it != m_bookmarks.end() ) {
        tmp += wxString::Format("%d:%d;", it->x, it->y ) + it->comment.c_str() + "\n";
        ++it;
    }

    pConfig->Write( wxString("bookmarks"), tmp );
}

void CProfile::SaveRecents( wxFileConfig *pConfig )
{
    wxString tmp;
    GoToArray::iterator it = m_recents.begin();

    while ( it != m_recents.end() ) {
        tmp += wxString::Format("%d:%d;", it->x, it->y );
        ++it;
    }

    pConfig->Write( wxString("recents"), tmp );
}

void CProfile::SetLastScrollPosition(int x, int y)
{
    m_last_scroll_x = x;
    m_last_scroll_y = y;
}

int CProfile::GetLastScrollPositionX() const
{
    return m_last_scroll_x;
}

int CProfile::GetLastScrollPositionY() const
{
    return m_last_scroll_y;
}

void CProfile::SetLastZoom( float zoom )
{
    m_last_zoom = zoom;
}

float CProfile::GetLastZoom( ) const
{
    return m_last_zoom;
}
//-------------------------------------------------------------------------
//END class CProfile
//-------------------------------------------------------------------------

//-------------------------------------------------------------------------
//BEGIN class CProfileManager
//-------------------------------------------------------------------------
CProfileManager::CProfileManager(wxFileConfig* pConfig)
    : m_pConfig(pConfig)
{
    m_pCurrentProfile = NULL;

    Init();
}

CProfileManager::~CProfileManager()
{
    vector <CProfile*>::iterator it = m_profiles.begin();
    for ( ; it != m_profiles.end(); it++)
    {
        delete (*it);
    }

    m_profiles.clear();
}

void CProfileManager::Init()
{
    int nProfiles, nLastProfile;

    // load all profiles
    m_pConfig->SetPath("/Profile");
    m_pConfig->Read( "profiles", &nProfiles, 0);
    m_pConfig->Read( "last_profile", &nLastProfile, 0);

    // read all profiles
    for (int i = 0; i < nProfiles; ++i)
    {
        wxString section("/Profile/");
        section << i;
        m_pConfig->SetPath( section );

        CProfile *p = new CProfile();
        p->Load( m_pConfig );
        m_profiles.push_back( p );
    }

    // Letzte Profil als aktuelles setzen
    CProfile *pProfile = GetProfile( nLastProfile );

    // Profil als aktuelles Profil setzen
    SetCurrentProfile( pProfile );
}

void CProfileManager::save()
{
    // save number of profiles
    m_pConfig->SetPath( "/Profile" );
    m_pConfig->Write( "profiles",     long(m_profiles.size()) );
    m_pConfig->Write( "last_profile", long(GetIndexFromProfile( m_pCurrentProfile )) );

    // save all profiles
    vector <CProfile*>::iterator it = m_profiles.begin();
    int i = 0;
    for ( ; it != m_profiles.end(); it++)
    {
        wxString section("/Profile/");
        section << i++;
        m_pConfig->SetPath( section );

        (*it)->Save( m_pConfig );
    }
}

int CProfileManager::size() const
{
    return m_profiles.size();
}

CProfile* CProfileManager::GetProfile (int index) const
{
    if (index >= int(m_profiles.size()) || index < 0)
        return 0L;
    else
        return m_profiles[index];
}

int CProfileManager::GetIndexFromProfile(const CProfile* profile)
{
    if ( !profile )
        return -1;

    vector <CProfile*>::iterator it = m_profiles.begin();
    int index = 0;

    for ( ; it != m_profiles.end(); it++)
    {
        if ((*it) == profile)
            return index;
        ++index;
    }

    return -1;
}

bool CProfileManager::DeleteProfile (int index)
{
    if (index >= int(m_profiles.size())) return false;

    CProfile* p = m_profiles[index];
    vector <CProfile*>::iterator result = find(m_profiles.begin(), m_profiles.end(), p);

    m_profiles.erase(result);
    delete p;
    p = 0;

    return true;
}

bool CProfileManager::DeleteProfile (CProfile* p)
{
    vector <CProfile*>::iterator result = find(m_profiles.begin(), m_profiles.end(), p);

    if (result == m_profiles.end()) return false;

    m_profiles.erase(result);
    delete p;
    p = 0;

    return true;
}

bool CProfileManager::AddProfile (CProfile* p)
{
    if (find(m_profiles.begin(), m_profiles.end(), p) == m_profiles.end()) {
        m_profiles.push_back(p);
        return true;
    } else {
        return false; // profile already exists
    }
}
//-------------------------------------------------------------------------
//END class CProfileManager
//-------------------------------------------------------------------------

}
// kate: space-indent off; tab-width 4; replace-tabs off;

---