path: root/lib/kofficecore/KoTemplates.cpp

/* This file is part of the KDE project
   Copyright (C) 2000 Werner Trobin <trobin@kde.org>

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

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
*/

#include <KoTemplates.h>

#include <tqdir.h>
#include <tqimage.h>
#include <tqprinter.h>

#include <kdesktopfile.h>
#include <ksimpleconfig.h>
#include <kdebug.h>
#include <tdeversion.h>
#include <kinstance.h>
#include <ksavefile.h>
#include <kstandarddirs.h>
#include <kiconloader.h>
#include <kio/netaccess.h>
#include <klocale.h>

#include <stdlib.h>


KoTemplate::KoTemplate(const TQString &name, const TQString &description, const TQString &file,
                       const TQString &picture, const TQString &fileName, const TQString &_measureSystem,
                       bool hidden, bool touched) :
    m_name(name), m_descr(description), m_file(file), m_picture(picture), m_fileName(fileName),
    m_hidden(hidden), m_touched(touched), m_cached(false), m_measureSystem(_measureSystem)
{
}

const TQPixmap &KoTemplate::loadPicture( TDEInstance* instance ) {

    if(m_cached)
        return m_pixmap;
    m_cached=true;
    if ( m_picture[ 0 ] == '/' )
    {
        // ### TODO: use the class KoPicture instead of TQImage to support non-image pictures
        TQImage img( m_picture );
        if (img.isNull()) {
            kdWarning() << "Couldn't find icon " << m_picture << endl;
            m_pixmap=TQPixmap();
            return m_pixmap;
        }
        const int maxHeightWidth = 128; // ### TODO: some people would surely like to have 128x128
        if (img.width() > maxHeightWidth || img.height() > maxHeightWidth) {
            img = img.smoothScale( maxHeightWidth, maxHeightWidth, TQ_ScaleMax );
        }
        m_pixmap.convertFromImage(img);
        return m_pixmap;
    } else { // relative path
        m_pixmap = instance->iconLoader()->loadIcon( m_picture, KIcon::Desktop, 128 );
        return m_pixmap;
    }
}


KoTemplateGroup::KoTemplateGroup(const TQString &name, const TQString &dir,
                                 int _sortingWeight, bool touched) :
    m_name(name), m_touched(touched), m_sortingWeight(_sortingWeight)
{
    m_dirs.append(dir);
    m_templates.setAutoDelete(true);
}

bool KoTemplateGroup::isHidden() const {

    TQPtrListIterator<KoTemplate> it(m_templates);
    bool hidden=true;
    while(it.current()!=0L && hidden) {
        hidden=it.current()->isHidden();
        ++it;
    }
    return hidden;
}

void KoTemplateGroup::setHidden(bool hidden) const {

    TQPtrListIterator<KoTemplate> it(m_templates);
    for( ; it.current()!=0L; ++it)
        it.current()->setHidden(hidden);
    m_touched=true;
}

bool KoTemplateGroup::add(KoTemplate *t, bool force, bool touch) {

    KoTemplate *myTemplate=find(t->name());
    if(myTemplate==0L) {
        m_templates.append(t);
        m_touched=touch;
        return true;
    }
    else if(myTemplate && force) {
        //kdDebug() << "removing :" << myTemplate->fileName() << endl;
        TQFile::remove( myTemplate->fileName()  );
        TQFile::remove( myTemplate->picture() );
        TQFile::remove( myTemplate->file() );
        m_templates.removeRef(myTemplate);
        m_templates.append(t);
        m_touched=touch;
        return true;
    }
    return false;
}

KoTemplate *KoTemplateGroup::find(const TQString &name) const {

    TQPtrListIterator<KoTemplate> it(m_templates);
    while(it.current() && it.current()->name()!=name)
        ++it;
    return it.current();
}


KoTemplateTree::KoTemplateTree(const TQCString &templateType,
                               TDEInstance *instance, bool readTree) :
    m_templateType(templateType), m_instance(instance), m_defaultGroup(0L),
    m_defaultTemplate(0L) {

    m_groups.setAutoDelete(true);
    if(readTree)
        readTemplateTree();
}

void KoTemplateTree::readTemplateTree() {

    readGroups();
    readTemplates();
}

void KoTemplateTree::writeTemplateTree() {
    TQString localDir=m_instance->dirs()->saveLocation(m_templateType);

    for(KoTemplateGroup *group=m_groups.first(); group!=0L; group=m_groups.next()) {
        //kdDebug() << "---------------------------------" << endl;
        //kdDebug() << "group: " << group->name() << endl;

        bool touched=false;
        for(KoTemplate *t=group->first(); t!=0L && !touched && !group->touched(); t=group->next())
            touched=t->touched();

        if(group->touched() || touched) {
            //kdDebug() << "touched" << endl;
            if(!group->isHidden()) {
                //kdDebug() << "not hidden" << endl;
                KStandardDirs::makeDir(localDir+group->name()); // create the local group dir
            }
            else {
                //kdDebug() << "hidden" << endl;
                if(group->dirs().count()==1 && !group->dirs().grep(localDir).isEmpty()) {
                    //kdDebug() << "local only" << endl;
                    KIO::NetAccess::del(group->dirs().first(), 0);
                    //kdDebug() << "removing: " << group->dirs().first() << endl;
                }
                else {
                    //kdDebug() << "global" << endl;
                    KStandardDirs::makeDir(localDir+group->name());
                }
            }
        }
        for(KoTemplate *t=group->first(); t!=0L; t=group->next()) {
            if(t->touched()) {
                //kdDebug() << "++template: " << t->name() << endl;
                writeTemplate(t, group, localDir);
            }
            if(t->isHidden() && t->touched() ) {
                //kdDebug() << "+++ delete local template ##############" << endl;
                writeTemplate(t, group, localDir);
                TQFile::remove(t->file());
                TQFile::remove(t->picture());
            }
        }
    }
}

void KoTemplateTree::add(KoTemplateGroup *g) {

    KoTemplateGroup *group=find(g->name());
    if(group==0L)
        m_groups.append(g);
    else
        group->addDir(g->dirs().first()); // "...there can be only one..." (Queen)
}

KoTemplateGroup *KoTemplateTree::find(const TQString &name) const {

    TQPtrListIterator<KoTemplateGroup> it(m_groups);
    while(it.current() && it.current()->name()!=name)
        ++it;
    return it.current();
}

void KoTemplateTree::readGroups() {

    TQStringList dirs = m_instance->dirs()->resourceDirs(m_templateType);
    for(TQStringList::ConstIterator it=dirs.begin(); it!=dirs.end(); ++it) {
        //kdDebug() << "dir: " << *it << endl;
        TQDir dir(*it);
        // avoid the annoying warning
        if(!dir.exists())
            continue;
        dir.setFilter(TQDir::Dirs);
        TQStringList templateDirs=dir.entryList();
        for(TQStringList::ConstIterator tdirIt=templateDirs.begin(); tdirIt!=templateDirs.end(); ++tdirIt) {
            if(*tdirIt=="." || *tdirIt=="..") // we don't want to check those dirs :)
                continue;
            TQDir templateDir(*it+*tdirIt);
            TQString name=*tdirIt;
            TQString defaultTab;
            int sortingWeight = 1000;
            if(templateDir.exists(".directory")) {
                KSimpleConfig config(templateDir.absPath()+"/.directory", true);
                config.setDesktopGroup();
                name=config.readEntry("Name");
                defaultTab=config.readEntry("X-TDE-DefaultTab");
                sortingWeight=config.readNumEntry("X-TDE-SortingWeight", 1000);
                //kdDebug() << "name: " << name <<endl;
            }
            KoTemplateGroup *g=new KoTemplateGroup(name, *it+*tdirIt+TQChar('/'), sortingWeight);
            add(g);
            if(defaultTab=="true")
                m_defaultGroup=g;
        }
    }
}

void KoTemplateTree::readTemplates() {
    TQString dontShow = "imperial";

    if(KGlobal::locale()->pageSize() == TQPrinter::Letter) {
        dontShow = "metric";
    }

    TQPtrListIterator<KoTemplateGroup> groupIt(m_groups);
    for( ; groupIt.current()!=0L; ++groupIt) {
        TQStringList dirs=groupIt.current()->dirs();
        for(TQStringList::ConstIterator it=dirs.begin(); it!=dirs.end(); ++it) {
            TQDir d(*it);
            if( !d.exists() )
                continue;
            TQStringList files=d.entryList( TQDir::Files | TQDir::Readable, TQDir::Name );
            for(unsigned int i=0; i<files.count(); ++i) {
                TQString filePath = *it + files[i];
                //kdDebug() << "filePath: " << filePath << endl;
                TQString icon;
                TQString text;
                TQString description;
                TQString hidden_str;
                TQString fileName;
                bool hidden=false;
                bool defaultTemplate = false;
                TQString templatePath;
                TQString measureSystem;
                // If a desktop file, then read the name from it.
                // Otherwise (or if no name in it?) use file name
                if (KDesktopFile::isDesktopFile(filePath)) {
                    KSimpleConfig config(filePath, true);
                    config.setDesktopGroup();
                    if (config.readEntry("Type")=="Link") {
                        text=config.readEntry("Name");
                        fileName=filePath;
                        description=config.readEntry("Comment");
                        //kdDebug() << "name: " << text << endl;
                        icon=config.readEntry("Icon");
                        if(icon[0]!='/' && // allow absolute paths for icons
                           TQFile::exists(*it+icon)) // allow icons from icontheme
                            icon=*it+icon;
                        //kdDebug() << "icon2: " << icon << endl;
                        hidden=config.readBoolEntry("X-TDE-Hidden", false);
                        defaultTemplate = config.readBoolEntry("X-TDE-DefaultTemplate", false);
                        measureSystem=config.readEntry("X-TDE-MeasureSystem").lower();

                        // Don't add a template that is for the wrong measure system
                        if(measureSystem == dontShow)
                            continue;

                        //kdDebug() << "hidden: " << hidden_str << endl;
                        templatePath=config.readPathEntry("URL");
                        //kdDebug() << "Link to : " << templatePath << endl;
                        if(templatePath[0]!='/') {
                            if(templatePath.left(6)=="file:/") // I doubt this will happen
                                templatePath=templatePath.right(templatePath.length()-6);
                            //else
                            //  kdDebug() << "dirname=" << *it << endl;
                            templatePath=*it+templatePath;
                            //kdDebug() << "templatePath: " << templatePath << endl;
                        }
                    } else
                        continue; // Invalid
                }
                // The else if and the else branch are here for compat. with the old system
                else if ( files[i].right(4) != ".png" )
                    // Ignore everything that is not a PNG file
                    continue;
                else {
                    // Found a PNG file - the template must be here in the same dir.
                    icon = filePath;
                    TQFileInfo fi(filePath);
                    text = fi.baseName();
                    templatePath = filePath; // Note that we store the .png file as the template !
                    // That's the way it's always been done. Then the app replaces the extension...
                }
                KoTemplate *t=new KoTemplate(text, description, templatePath, icon, fileName,
                                             measureSystem, hidden);
                groupIt.current()->add(t, false, false); // false -> we aren't a "user", false -> don't
                                                         // "touch" the group to avoid useless
                                                         // creation of dirs in .kde/blah/...
                if ( defaultTemplate )
                    m_defaultTemplate = t;
            }
        }
    }
}

void KoTemplateTree::writeTemplate(KoTemplate *t, KoTemplateGroup *group,
                                   const TQString &localDir) {
    TQString fileName;
    if ( t->isHidden() )
    {
        fileName = t->fileName();
        // try to remove the file
        if ( TQFile::remove(fileName) || !TQFile::exists(fileName) )
        {
            TQFile::remove( t->name() );
            TQFile::remove( t->picture() );
            return;
        }
    }
    // be sure that the template's file name is unique so we don't overwrite an other
    TQString const path = localDir + group->name() + '/';
    TQString const name = KoTemplates::stripWhiteSpace( t->name() );
    fileName = path + name + ".desktop";
    if ( t->isHidden() && TQFile::exists(fileName) )
        return;
    TQString fill;
    while ( KIO::NetAccess::exists( fileName, true, 0 ) )
    {
        fill += '_';
        fileName = path + fill + name + ".desktop";
    }

    KSimpleConfig config( fileName );
    config.setDesktopGroup();
    config.writeEntry("Type", "Link");
    config.writePathEntry("URL", t->file());
    config.writeEntry("Name", t->name());
    config.writeEntry("Icon", t->picture());
    config.writeEntry("X-TDE-Hidden", t->isHidden());
}

namespace KoTemplates {
TQString stripWhiteSpace(const TQString &string) {

    TQString ret;
    for(unsigned int i=0; i<string.length(); ++i) {
        TQChar tmp(string[i]);
        if(!tmp.isSpace())
            ret+=tmp;
    }
    return ret;
}
}