klfliblegacyengine_p.h

Go to the documentation of this file.

/***************************************************************************
 *   file klfliblegacyengine_p.h
 *   This file is part of the KLatexFormula Project.
 *   Copyright (C) 2011 by Philippe Faist
 *   philippe.faist at bluewin.ch
 *                                                                         *
 *   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.             *
 ***************************************************************************/
/* $Id: klfliblegacyengine_p.h 603 2011-02-26 23:14:55Z phfaist $ */


#ifndef KLFLIBLEGACYENGINE_P_H
#define KLFLIBLEGACYENGINE_P_H

#include <QObject>
#include <QMap>
#include <QFileInfo>

#include "klfliblegacyengine.h"

class KLFLibLegacyFileDataPrivate : public QObject
{
  Q_OBJECT
public:
  static inline KLFLibLegacyFileDataPrivate * instanceFor(const QString fname, bool starttimer)
  {
    QString f = canonicalFilePath(fname);
    klfDbg("fname="<<fname<<"; canonical f="<<f<<"; starttimer="<<starttimer) ;
    if (f.isEmpty()) {
      qWarning()<<KLF_FUNC_NAME<<": error getting canonical file path for "<<fname<<".";
      return NULL;
    }
    if (staticFileDataObjects.contains(f))
      return staticFileDataObjects[f];
    KLFLibLegacyFileDataPrivate *d = new KLFLibLegacyFileDataPrivate(f);
    if (starttimer && !d->autoSaveTimer->isActive())
      d->autoSaveTimer->start(180000); // 180s = 3min
    return d;
  }

  static QString canonicalFilePath(const QString& fname)
  {
    QFileInfo fi(fname);
    if (fi.exists())
      return fi.canonicalFilePath();
    // non-existing file. Rely on existing directory
    QString containdir = fi.absolutePath();
    klfDbg("non-existing file "<<fname<<": containing dir="<<containdir) ;
    QFileInfo di(containdir);
    if (!di.exists() || !di.isDir()) {
      qWarning()<<KLF_FUNC_NAME<<": Path "<<fname<<": directory "<<containdir<<" does not exist.";
      return QString();
    }
    QString canonical = QFileInfo(containdir).canonicalFilePath();
    if (canonical.isEmpty()) {
      qWarning()<<KLF_FUNC_NAME<<": Error getting "<<containdir<<"'s canonical path.";
      return QString();
    }
    if (!canonical.endsWith("/"))
      canonical += "/";
    canonical += fi.fileName();
    return canonical;
  }

  ~KLFLibLegacyFileDataPrivate()
  {
    klfDbg("destroying. Possibly save? haschanges="<<haschanges) ;
    if (haschanges)
      save();

    staticFileDataObjects.remove(filename);
    delete autoSaveTimer;
  }

  inline void ref() { ++refcount; }
  inline int deref() { return --refcount; }

  inline QString fileName() const { return filename; }


  enum LegacyLibType { LocalHistoryType = 1, LocalLibraryType, ExportLibraryType };

  bool haschanges;

  KLFLegacyData::KLFLibrary library;
  KLFLegacyData::KLFLibraryResourceList resources;

  QVariantMap metadata;

  LegacyLibType legacyLibType;

  QTimer *autoSaveTimer;

  int findResourceName(const QString& resname);
  int getReservedResourceId(const QString& resourceName, int defaultId);



  static inline KLFLibEntry toLibEntry(const KLFLegacyData::KLFLibraryItem& item)
  {
    return KLFLibEntry(KLFLibEntry::stripCategoryTagsFromLatex(item.latex), item.datetime,
                       item.preview.toImage(), item.preview.size(), item.category,
                       item.tags, toStyle(item.style));
  }
  static inline KLFLegacyData::KLFLibraryItem toLegacyLibItem(const KLFLibEntry& entry)
  {
    KLFLegacyData::KLFLibraryItem item;
    item.id = KLFLegacyData::KLFLibraryItem::MaxId++;
    // ensure latex has category & tags information
    item.latex = KLFLibEntry::latexAddCategoryTagsComment(KLFLibEntry::stripCategoryTagsFromLatex(entry.latex()),
                                                          entry.category(), entry.tags()) ;
    item.category = entry.category();
    item.tags = entry.tags();
    item.preview = QPixmap::fromImage(entry.preview());
    item.datetime = entry.dateTime();
    item.style = toLegacyStyle(entry.style());
    return item;
  }
  static inline KLFLegacyData::KLFStyle toLegacyStyle(const KLFStyle& style)
  {
    KLFLegacyData::KLFStyle oldstyle;
    oldstyle.name = style.name;
    oldstyle.fg_color = style.fg_color;
    oldstyle.bg_color = style.bg_color;
    oldstyle.mathmode = style.mathmode;
    oldstyle.preamble = style.preamble;
    oldstyle.dpi = style.dpi;
    return oldstyle;
  }
  static inline KLFStyle toStyle(const KLFLegacyData::KLFStyle& oldstyle)
  {
    KLFStyle style;
    style.name = oldstyle.name;
    style.fg_color = oldstyle.fg_color;
    style.bg_color = oldstyle.bg_color;
    style.mathmode = oldstyle.mathmode;
    style.preamble = oldstyle.preamble;
    style.dpi = oldstyle.dpi;
    return style;
  }

signals:
  void resourcePropertyChanged(int propId);

public slots:
  bool load(const QString& fname = QString());

  bool save(const QString& fname = QString());

  void emitResourcePropertyChanged(int propId) { emit resourcePropertyChanged(propId); }

private:
  KLFLibLegacyFileDataPrivate() { }

  KLFLibLegacyFileDataPrivate(const QString& fname) : refcount(0), filename(fname)
  {
    klfDbg(" filename is "<<filename ) ;

    staticFileDataObjects[filename] = this;

    if (QFile::exists(fname))
      load(); // load the data

    // by default, we're a .klf export type
    legacyLibType = ExportLibraryType;

    // prepare the autosave timer
    autoSaveTimer = new QTimer(NULL);
    autoSaveTimer->setSingleShot(false);
    connect(autoSaveTimer, SIGNAL(timeout()), this, SLOT(save()));
  }

  int refcount;

  QString filename;

  static QMap<QString,KLFLibLegacyFileDataPrivate*> staticFileDataObjects;

};




#endif