format.h

Go to the documentation of this file.

/*

    This file is part of the KFloppy program, part of the KDE project
    
    Copyright (C) 2002 Adriaan de Groot <groot@kde.org>
    Copyright (C) 2004, 2005 Nicolas GOUTTE <goutte@kde.org>


    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, version 2.

    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., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

*/

#ifndef FORMAT_H
#define FORMAT_H

#include "debug.h"
#include <QObject>

class KFAction : public QObject
{
Q_OBJECT

public:
    KFAction(QObject *parent = 0L);
    virtual ~KFAction();
    
public slots:
    virtual void exec();
    virtual void quit();
    
signals:
    void done(KFAction *me,bool success);

    void status(const QString &msg, int progress);

    void error(const QString &msg, const QString &details);
} ;


class KFActionQueue : public KFAction
{
Q_OBJECT

public:
    KFActionQueue(QObject *parent = 0L);
    virtual ~KFActionQueue();
    
    void queue(KFAction *);
    
    virtual void exec();

protected slots:
    void actionDone(KFAction *,bool);
    
private:
    class KFActionQueue_p *d;
} ;


/*
** The remainder of the Actions are concrete ones and
** might better go off to live in another header file,
** but this is only needed if the number of supported
** formats grows enormously.
*/

typedef struct { const char * const * devices;
    int drive;
    int blocks;
    int tracks;
    int flags; } fdinfo;

class K3Process;

class FloppyAction : public KFAction
{
Q_OBJECT

public:
    FloppyAction(QObject *parent = 0L);
    
    virtual void quit();
    
    bool configureDevice(int driveno, int density );

        bool configureDevice( const QString& newDeviceName );
        
protected:
    const fdinfo *deviceInfo;      
    QString deviceName;  

protected slots:
    virtual void processDone(K3Process *);
    virtual void processStdOut(K3Process *, char *, int);
    virtual void processStdErr(K3Process *, char *, int);
    
protected:
    K3Process *theProcess;
    QString theProcessName;  

    bool startProcess();
} ;

class FDFormat : public FloppyAction
{
public:
    FDFormat(QObject *parent = 0L);
    
    virtual void exec();

    
    static bool runtimeCheck();
        
    bool configure(bool verify);
    
    virtual void processStdOut(K3Process *, char *,int);

protected:
    static QString fdformatName;    
    int formatTrackCount;    
    bool doVerify;
} ;

class DDZeroOut : public FloppyAction
{
public:
    DDZeroOut(QObject *parent = 0L);

    virtual void exec();

    static bool runtimeCheck();           

protected:
    virtual void processDone(K3Process *);
protected:
    static QString m_ddName;    
} ;


class FATFilesystem : public FloppyAction
{
public:
    FATFilesystem(QObject *parent = 0L);
    
    virtual void exec();
    
    static bool runtimeCheck();

    bool configure(bool verify, bool label, const QString &l);
    
        virtual void processStdOut(K3Process*, char* b, int l);
        
protected:
    static QString newfs_fat;
    
    bool doVerify,doLabel;
    QString label;
    
} ;

class Ext2Filesystem : public FloppyAction
{
public:
    Ext2Filesystem(QObject *parent = 0L);
    
    virtual void exec();
    
    static bool runtimeCheck();
    
    bool configure(bool verify, bool label, const QString &l);

        virtual void processStdOut(K3Process*, char* b, int l);
    
protected:
    static QString newfs;
    
    bool doVerify,doLabel;
    QString label;
} ;

#ifdef ANY_BSD

class UFSFilesystem : public FloppyAction
{
public:
    UFSFilesystem(QObject *parent = 0L);
    
    virtual void exec();
    
    static bool runtimeCheck();
    
protected:
    static QString newfs;
    
    bool doVerify,doLabel;
    QString label;
} ;
#endif

#ifdef ANY_LINUX

class MinixFilesystem : public FloppyAction
{
public:
    MinixFilesystem(QObject *parent = 0L);
    
    virtual void exec();
    
    static bool runtimeCheck();
    
    bool configure(bool verify, bool label, const QString &l);
        
        virtual void processStdOut(K3Process*, char* b, int l);
protected:
    static QString newfs;
    
    bool doVerify,doLabel;
    QString label;
} ;
#endif

QString findExecutable(const QString &);

#endif