# kdeprint Library API Documentation

Overview | Class Hierarchy | Classes | Classes (annotated) | Members | Namespaces | Source Files

# kmprinter.h

    00001 /*
    00002  *  This file is part of the KDE libraries
    00003  *  Copyright (c) 2001 Michael Goffioul <kdeprint@swing.be>
    00004  *
    00005  *  This library is free software; you can redistribute it and/or
    00006  *  modify it under the terms of the GNU Library General Public
    00007  *  License version 2 as published by the Free Software Foundation.
    00008  *
    00009  *  This library is distributed in the hope that it will be useful,
    00010  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
    00011  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    00012  *  Library General Public License for more details.
    00013  *
    00014  *  You should have received a copy of the GNU Library General Public License
    00015  *  along with this library; see the file COPYING.LIB.  If not, write to
    00016  *  the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
    00017  *  Boston, MA 02111-1307, USA.
    00018  **/
    00019
    00020 #ifndef KMPRINTER_H
    00021 #define KMPRINTER_H
    00022
    00023 #if !defined( _KDEPRINT_COMPILE ) && defined( __GNUC__ )
    00024 #warning internal header, do not use except if you are a KDEPrint developer
    00025 #endif
    00026
    00027 #include <qstring.h>
    00028 #include <qstringlist.h>
    00029 #include <qptrlist.h>
    00030 #include <kurl.h>
    00031 #include <qmap.h>
    00032 #include <kdeprint/kmobject.h>
    00033
    00034 class KMDBEntry;
    00035 class DrMain;
    00036 class KPrinter;
    00037 class QWidget;
    00038
    00046 class KDEPRINT_EXPORT KMPrinter : public KMObject
    00047 {
    00048 public:
    00049     enum PrinterType {
    00050         Printer  = 0x01,
    00051         Class    = 0x02,
    00052         Implicit = 0x04,
    00053         Virtual  = 0x08,
    00054         Remote   = 0x10,
    00055         Invalid  = 0x20,
    00056         Special  = 0x40
    00057     };
    00058     enum PrinterState {
    00059         Idle       = 0x01,
    00060         Stopped    = 0x02,
    00061         Processing = 0x03,
    00062         Unknown    = 0x04,
    00063         Rejecting  = 0x08,
    00064         StateMask  = 0x07
    00065     };
    00066     enum PrinterCap {
    00067         CapBW       = 0x0001,
    00068         CapColor    = 0x0002,
    00069         CapDuplex   = 0x0004,
    00070         CapStaple   = 0x0008,
    00071         CapCopies   = 0x0010,
    00072         CapCollate  = 0x0020,
    00073         CapPunch    = 0x0040,
    00074         CapCover    = 0x0080,
    00075         CapBind     = 0x0100,
    00076         CapSort     = 0x0200,
    00077         CapSmall    = 0x0400,
    00078         CapMedium   = 0x0800,
    00079         CapLarge    = 0x1000,
    00080         CapVariable = 0x2000
    00081     };
    00082
    00083     // constructor functions
    00084     KMPrinter();
    00085     KMPrinter(const KMPrinter& p);
    00086     ~KMPrinter();
    00087     void copy(const KMPrinter& p);
    00088
    00089
    00090     // inline access functions
    00091     const QString& name() const     { return m_name; }
    00092     void setName(const QString& s)      { m_name = s; if (m_printername.isEmpty()) m_printername = s; }
    00093     const QString& printerName() const  { return m_printername; }
    00094     void setPrinterName(const QString& s)   { m_printername = s; if (m_name.isEmpty()) m_name = s; }
    00095     const QString& instanceName() const { return m_instancename; }
    00096     void setInstanceName(const QString& s)  { m_instancename = s; }
    00097     int type() const            { return m_type; }
    00098     void setType(int t)             { m_type = t; }
    00099     void addType(int t)             { m_type |= t; }
    00100     PrinterState state(bool complete = false) const         { return PrinterState(m_state & (complete ? ~0x0 : StateMask)); }
    00101     QString stateString() const;
    00102     void setState(PrinterState s)       { m_state = PrinterState((m_state & ~StateMask) | s); }
    00103     bool acceptJobs() const         { return !(m_state & Rejecting); }
    00104     void setAcceptJobs(bool on)     { m_state = PrinterState((m_state & StateMask) | (on ? 0 : Rejecting)); }
    00105     const QString& device() const       { return m_device; }
    00106     QString deviceProtocol() const;
    00107     void setDevice(const QString& d)        { m_device = d; }
    00108     const QStringList& members() const  { return m_members; }
    00109     void setMembers(const QStringList& l)   { m_members = l; }
    00110     void addMember(const QString& s)    { m_members.append(s); }
    00111     const QString& description() const  { return m_description; }
    00112     void setDescription(const QString& s)   { m_description = s; }
    00113     const QString& location() const     { return m_location; }
    00114     void setLocation(const QString& s)  { m_location = s; }
    00115     const KURL& uri() const         { return m_uri; }
    00116     void setUri(const KURL& u)      { m_uri = u; }
    00117     const QString& manufacturer() const { return m_manufacturer; }
    00118     void setManufacturer(const QString&s )  { m_manufacturer = s; }
    00119     const QString& model() const        { return m_model; }
    00120     void setModel(const QString& s)     { m_model = s; }
    00121     const QString& driverInfo() const   { return m_driverinfo; }
    00122     void setDriverInfo(const QString& s)    { m_driverinfo = s; }
    00123     int printerCap() const              { return m_printercap; }
    00124     void setPrinterCap( int c )         { m_printercap = c; }
    00125     void addPrinterCap( int c )         { m_printercap |= c; }
    00126
    00127     // some useful functions
    00128     bool isClass(bool useImplicit = true) const { return ((m_type & KMPrinter::Class) || (useImplicit && isImplicit())); }
    00129     bool isImplicit() const             { return (m_type & KMPrinter::Implicit); }
    00130     bool isPrinter() const              { return (m_type & KMPrinter::Printer); }
    00131     bool isRemote() const               { return (m_type & KMPrinter::Remote); }
    00132     bool isLocal() const                { return !isRemote(); }
    00133     bool isVirtual() const              { return (m_type & KMPrinter::Virtual); }
    00134     bool isValid() const                { return !(m_type & KMPrinter::Invalid); }
    00135     bool isSpecial() const              { return (m_type & KMPrinter::Special); }
    00136
    00137     // misc
    00138     KMDBEntry* dbEntry() const  { return m_dbentry; }
    00139     void setDbEntry(KMDBEntry *e)   { m_dbentry = e; }
    00140     QString pixmap();
    00141     void setPixmap(const QString& s)    { m_pixmap = s; }
    00142     bool isHardDefault() const  { return m_harddefault; }
    00143     void setHardDefault(bool on)    { m_harddefault = on; }
    00144     bool isSoftDefault() const  { return m_softdefault; }
    00145     void setSoftDefault(bool on)    { m_softdefault = on; }
    00146     bool ownSoftDefault() const { return m_ownsoftdefault; }
    00147     void setOwnSoftDefault(bool on) { m_ownsoftdefault = on; }
    00148     static int compare(KMPrinter *p1, KMPrinter *p2);
    00149     const QString& option(const QString& key) const         { return m_options[key]; }
    00150     bool hasOption(const QString& key) const            { return m_options.contains(key); }
    00151     void setOption(const QString& key, const QString& value)    { if (!key.isEmpty()) m_options[key] = value; }
    00152     void removeOption(const QString& key)               { m_options.remove(key); }
    00153     QMap<QString,QString> options() const               { return m_options; }
    00154     void setOptions(const QMap<QString,QString>& opts)      { m_options = opts; }
    00155     DrMain* driver() const                      { return m_driver; }
    00156     void setDriver(DrMain*);
    00157     DrMain* takeDriver();
    00158
    00159     // configure an existing KPrinter object
    00160     bool autoConfigure(KPrinter *prt, QWidget *parent = 0);
    00161
    00162     // default options
    00163     const QString& defaultOption(const QString& key) const      { return m_defaultoptions[key]; }
    00164     void setDefaultOption(const QString& key, const QString& value) { if (!key.isEmpty()) m_defaultoptions[key] = value; }
    00165     QMap<QString,QString> defaultOptions() const            { return m_defaultoptions; }
    00166     void setDefaultOptions(const QMap<QString,QString>& opts)   { m_defaultoptions = opts; }
    00167     // edited options
    00168     const QString& editedOption(const QString& key) const       { return m_editedoptions[key]; }
    00169     void setEditedOption(const QString& key, const QString& value)  { if (!key.isEmpty()) m_editedoptions[key] = value; }
    00170     QMap<QString,QString> editedOptions() const             { return m_editedoptions; }
    00171     void setEditedOptions(const QMap<QString,QString>& opts)    { m_editedoptions = opts; }
    00172     // edited flag
    00173     bool isEdited() const   { return m_isedited; }
    00174     void setEdited(bool on) { m_isedited = on; }
    00175
    00176
    00177 protected:
    00178     // mandantory information
    00179     QString     m_name;     // identification name
    00180     QString     m_printername;  // real printer name
    00181     QString     m_instancename; // instance name (human-readable)
    00182     int     m_type;     // printer type (any PrinterType flag OR-ed together)
    00183     PrinterState    m_state;    // printer state
    00189     QString     m_device;   // printer device
    00190
    00191     // class specific information
    00192     QStringList m_members;  // members of the class
    00193
    00194     // other useful information that should be completed by manager on demand
    00195     QString     m_description;  // short description, comment
    00196     QString     m_location; // printer location
    00197     KURL        m_uri;      // URI printer identification
    00198     QString     m_manufacturer; // printer manufacturer (driver)
    00199     QString     m_model;    // printer model (driver)
    00200     QString     m_driverinfo;   // short driver info (ex: nick name in PPD)
    00201
    00202     // DB driver entry (used when creating a printer). Internal use only !!!
    00203     KMDBEntry   *m_dbentry;
    00204     DrMain      *m_driver;
    00205     QString     m_pixmap;
    00206
    00207     // default flags
    00208     bool        m_harddefault;
    00209     bool        m_softdefault;
    00210         bool            m_ownsoftdefault;
    00211
    00212     // other options (for any use)
    00213     QMap<QString,QString>   m_options;
    00214
    00215     // options used for instances, and print library. These options are not
    00216     // overwritten when copying from another KMPrinter object. This allows to
    00217     // to keep the user settings through an application session. The difference
    00218     // between "default" and "edited" can be used for option saving (only save
    00219     // the options corresponding to current edited printer).
    00220     QMap<QString,QString>   m_defaultoptions;
    00221     QMap<QString,QString>   m_editedoptions;
    00222     bool            m_isedited;
    00223
    00224     // printer capabilities (based on CUPS model)
    00225     int m_printercap;
    00226 };
    00227
    00228 class KMPrinterList : public QPtrList<KMPrinter>
    00229 {
    00230 public:
    00231     KMPrinterList() : QPtrList<KMPrinter>() {}
    00232     virtual int compareItems(QPtrCollection::Item i1, QPtrCollection::Item i2)
    00233     { return KMPrinter::compare((KMPrinter*)i1, (KMPrinter*)i2); }
    00234 };
    00235
    00236 #endif

This file is part of the documentation for kdeprint Library Version 3.4.1.
Documentation copyright © 1996-2004 the KDE developers.
Generated on Sat Jun 11 20:31:03 2005 by doxygen 1.4.1 written by Dimitri van Heesch, © 1997-2003