You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
338 lines
8.9 KiB
338 lines
8.9 KiB
/***************************************************************************
|
|
begin : mon 3-11 20:40:00 CEST 2003
|
|
copyright : (C) 2003 by Jeroen Wijnhout
|
|
email : Jeroen.Wijnhout@kdemail.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. *
|
|
* *
|
|
***************************************************************************/
|
|
|
|
#ifndef KILETOOL_H
|
|
#define KILETOOL_H
|
|
|
|
#include "kilelauncher.h"
|
|
|
|
#include <tqobject.h>
|
|
#include <tqmap.h>
|
|
#include <tqstring.h>
|
|
#include <tqdict.h>
|
|
#include <tqstringlist.h>
|
|
|
|
class TDEConfig;
|
|
class KileInfo;
|
|
class KShellProcess;
|
|
class KileProject;
|
|
|
|
namespace KileTool
|
|
{
|
|
typedef TQMap<TQString,TQString> Config;
|
|
|
|
class Manager;
|
|
|
|
/**
|
|
* A class that defines a general tool (latex, dvips etc.) to be launched from
|
|
* within Kile.
|
|
*
|
|
* @author Jeroen Wijnhout
|
|
**/
|
|
|
|
class Base : public TQObject
|
|
{
|
|
Q_OBJECT
|
|
|
|
|
|
public:
|
|
Base(const TQString &name, Manager *manager, bool prepare = true);
|
|
~Base();
|
|
|
|
/**
|
|
* Sets the KileInfo object, this is already taken care of by the Manager.
|
|
**/
|
|
void setInfo(KileInfo *ki) { m_ki = ki; }
|
|
|
|
/**
|
|
* Sets the TDEConfig object, this is already taken care of by the Manager.
|
|
**/
|
|
void setConfig(TDEConfig *config) { m_config = config; }
|
|
|
|
/**
|
|
* @returns the Manager object for this tool.
|
|
**/
|
|
Manager* manager() const { return m_manager; }
|
|
|
|
/**
|
|
* @returns a short descriptive name for this tool.
|
|
**/
|
|
const TQString& name() const { return m_name; }
|
|
|
|
/**
|
|
* Allows you to set the source file explicitly (absolute path).
|
|
**/
|
|
virtual void setSource(const TQString & source);
|
|
|
|
/**
|
|
* @returns the source file that is used to run the tool on.
|
|
**/
|
|
const TQString source(bool absolute = true) const;
|
|
|
|
const TQString S() const { return m_S; }
|
|
const TQString baseDir() const { return m_basedir; }
|
|
const TQString relativeDir() const { return m_relativedir; }
|
|
const TQString targetDir() const { return m_targetdir; }
|
|
const TQString from() const { return m_from; }
|
|
const TQString to() const { return m_to; }
|
|
const TQString target() const { return m_target; }
|
|
const TQString options() const { return m_options; }
|
|
|
|
void setOptions(const TQString &opt) { m_options = opt; }
|
|
|
|
virtual bool isViewer() { return false; }
|
|
|
|
void setQuickie() { m_quickie = true; }
|
|
bool isQuickie() { return m_quickie; }
|
|
|
|
/**
|
|
* Allows you to set the target file explicitly (filename only).
|
|
**/
|
|
virtual void setTarget(const TQString & target);
|
|
virtual void setTargetDir(const TQString & target);
|
|
virtual void setTargetPath(const TQString & target);
|
|
|
|
/**
|
|
* Sets the target directory relative to the source directory.
|
|
**/
|
|
void setRelativeBaseDir(const TQString & dir) { m_relativedir = dir; }
|
|
|
|
/**
|
|
* Installs a launcher object that will be responsible for actually starting the tool. The
|
|
* tool can be a command-line tool or a kpart, the KileTool class doesn't need to know
|
|
* about the specifics of the launcher.
|
|
**/
|
|
void installLauncher(Launcher *lr );
|
|
|
|
/**
|
|
* Installs a launcher as indicated by the tool type. This creates a launcher object.
|
|
**/
|
|
bool installLauncher();
|
|
|
|
/**
|
|
* @returns a pointer to the launcher object, returns 0 if no launcher is installed.
|
|
**/
|
|
Launcher *launcher() { return m_launcher; }
|
|
|
|
/**
|
|
* @returns the working dir for this tool.
|
|
**/
|
|
const TQString &workingDir() const { return m_basedir; }
|
|
|
|
/**
|
|
* @returns the dictionary that translates the following keys
|
|
Example docu:
|
|
Consider a file which is called myBestBook.tex which resides in /home/thomas/latex and you compile it with pdflatex to myBestBook.pdf.
|
|
|
|
The variables have the following meanings:
|
|
%source -> filename with suffix but without path <-> myBestBook.tex
|
|
%S -> filename without suffix but without path <-> myBestBook
|
|
%dir_base -> path of the source file without filename <-> /home/thomas/latex
|
|
%dir_target -> path of the target file without filename, same as %dir_base if no relative path has been set <-> /home/thomas/latex
|
|
%target -> target filename without path <-> without filename
|
|
|
|
And these are special variables
|
|
%res <-> resolution of the quickpreview action set in configure kile->tools->preview
|
|
|
|
%AFL <-> List of all files in a project marked for archiving. You can set the archive flag in the "Files and projects" sidebar using the context menu.
|
|
|
|
*/
|
|
TQDict<TQString>* paramDict() { return &m_dictParams; }
|
|
|
|
bool addDict(const TQString & key, const TQString & value);
|
|
|
|
void translate(TQString &str);
|
|
|
|
void setFlags(uint flags) { m_flags = flags; }
|
|
uint flags() { return m_flags; }
|
|
|
|
void setMsg(long n, const TQString & msg);
|
|
TQString msg(long n) const { return m_messages[n]; }
|
|
|
|
protected:
|
|
bool needsUpdate(const TQString &target, const TQString &source);
|
|
|
|
public slots:
|
|
void sendMessage(int, const TQString &);
|
|
virtual void filterOutput(const TQString &);
|
|
|
|
signals:
|
|
void message(int, const TQString &, const TQString &);
|
|
void output(const TQString &);
|
|
|
|
void start(Base*);
|
|
void done(Base*, int);
|
|
|
|
void requestSaveAll(bool amAutoSaving = false, bool disUntitled= false);
|
|
|
|
public:
|
|
void setEntryMap(Config map) { m_entryMap = map; }
|
|
const TQString readEntry(const TQString & key) { return m_entryMap[key]; }
|
|
|
|
public:
|
|
virtual void prepareToRun(const TQString &cfg = TQString());
|
|
bool isPrepared() { return m_bPrepared; }
|
|
bool needsToBePrepared() { return m_bPrepareToRun; }
|
|
|
|
protected:
|
|
/**
|
|
* Checks if the prerequisites are in order.
|
|
* @returns true if everything is ok, false otherwise.
|
|
**/
|
|
virtual bool checkPrereqs();
|
|
|
|
/**
|
|
* Determines on which file to run the tool.
|
|
**/
|
|
virtual bool determineSource();
|
|
|
|
/**
|
|
* Determines the target of the tool (i.e. a DVI for latex, PS for dvips) and
|
|
* checks if the target file can be written to the specified location.
|
|
**/
|
|
virtual bool determineTarget();
|
|
|
|
/**
|
|
* Check if the target dir and file have the correct permissions (according to the flags set).
|
|
**/
|
|
virtual bool checkTarget();
|
|
|
|
virtual bool checkSource();
|
|
|
|
public:
|
|
/**
|
|
* Configures the tool object.
|
|
**/
|
|
virtual bool configure(const TQString & cfg = TQString());
|
|
|
|
public slots:
|
|
/**
|
|
* Starts the tool. First it performs basic checks (checkPrereqs()),
|
|
* if all is well it launches the tool (launch()). After the process has
|
|
* exited it calls finish().
|
|
* @return the exit code of the tool (if available)
|
|
**/
|
|
virtual int run();
|
|
|
|
/**
|
|
* Terminates the running process.
|
|
**/
|
|
virtual void stop();
|
|
|
|
/**
|
|
* Clean up after the process/lib has finished.
|
|
**/
|
|
virtual bool finish(int);
|
|
|
|
private:
|
|
Manager *m_manager;
|
|
KileInfo *m_ki;
|
|
TDEConfig *m_config;
|
|
|
|
TQString m_name, m_from, m_to;
|
|
TQString m_target, m_basedir, m_relativedir, m_targetdir, m_source, m_S, m_options;
|
|
TQString m_resolution;
|
|
|
|
TQString m_message;
|
|
|
|
bool m_buildPrereqs;
|
|
|
|
protected:
|
|
Launcher *m_launcher;
|
|
bool m_quickie;
|
|
|
|
private:
|
|
TQDict<TQString> m_dictParams;
|
|
Config m_entryMap;
|
|
|
|
uint m_flags;
|
|
int m_nPreparationResult;
|
|
bool m_bPrepared;
|
|
bool m_bPrepareToRun;
|
|
|
|
//messages
|
|
TQMap<long,TQString> m_messages;
|
|
};
|
|
|
|
/**
|
|
* A class that represents a compile tool (such as latex, pdflatex).
|
|
**/
|
|
class Compile : public Base
|
|
{
|
|
public:
|
|
Compile(const TQString &name, Manager * manager, bool prepare = true);
|
|
~Compile();
|
|
|
|
protected:
|
|
bool checkSource();
|
|
};
|
|
|
|
/**
|
|
* A class that represents a view tool (such as KDVI, gv, etc.).
|
|
**/
|
|
class View : public Base
|
|
{
|
|
public:
|
|
View(const TQString &name, Manager * manager, bool prepare = true);
|
|
~View();
|
|
|
|
bool isViewer() { return true; }
|
|
};
|
|
|
|
/**
|
|
* A class that represents a conversion tool (such as dvips).
|
|
**/
|
|
class Convert : public Base
|
|
{
|
|
public:
|
|
Convert(const TQString &name, Manager * manager, bool prepare = true);
|
|
~Convert();
|
|
|
|
bool determineSource();
|
|
};
|
|
|
|
/**
|
|
* A class that represents a tool like tar, from multiple files to one file
|
|
**/
|
|
class Archive: public Base
|
|
{
|
|
Q_OBJECT
|
|
|
|
|
|
public:
|
|
Archive(const TQString &name, Manager * manager, bool prepare = true);
|
|
~Archive();
|
|
bool checkPrereqs();
|
|
void setSource(const TQString & source);
|
|
private:
|
|
KileProject *m_project;
|
|
TQString m_fileList;
|
|
};
|
|
|
|
class Sequence : public Base
|
|
{
|
|
Q_OBJECT
|
|
|
|
|
|
public:
|
|
Sequence(const TQString &name, Manager * manager, bool prepare = true);
|
|
|
|
public slots:
|
|
int run();
|
|
};
|
|
}
|
|
|
|
#endif
|