/***************************************************************************
date : Sep 15 2004
version : 0.23
copyright : Thomas Fischer < t - fisch @ users . sourceforge . net >
restructured , improved and completed by Holger Danielsson
( C ) 2004 by Holger Danielsson
email : holger . danielsson @ t - online . de
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/***************************************************************************
* *
* 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 . *
* *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
# include "quickdocumentdialog.h"
# include <tqstringlist.h>
# include <tqtabwidget.h>
# include <tqlayout.h>
# include <tqwidget.h>
# include <tqcheckbox.h>
# include <tqlabel.h>
# include <tqlistbox.h>
# include <tqpainter.h>
# include <tqpalette.h>
# include <tqstyle.h>
# include <tqlistview.h>
# include <tqwhatsthis.h>
# include <tqregexp.h>
# include <kcombobox.h>
# include <klocale.h>
# include <kconfig.h>
# include <klineedit.h>
# include <kiconloader.h>
# include <kpushbutton.h>
# include <kmessagebox.h>
# include "kiledebug.h"
# include "kileconfig.h"
namespace KileDialog
{
enum {
qd_Base = 1 ,
qd_Article = 2 ,
qd_BookReport = 4 ,
qd_KomaArticle = 8 ,
qd_KomaBookReport = 16 ,
qd_KomaAbstract = 32 ,
qd_Prosper = 64 ,
qd_Beamer = 128
} ;
// list with index numbers for the stringlist with all information of a document class
enum {
qd_Fontsizes ,
qd_Papersizes ,
qd_DefaultOptions ,
qd_SelectedOptions ,
qd_OptionsStart
} ;
//////////////////// ListBoxSeparator ////////////////////
class ListBoxSeparator : public TQListBoxItem
{
public :
ListBoxSeparator ( int h ) ;
protected :
virtual void paint ( TQPainter * ) ;
virtual int width ( const TQListBox * ) const { return listBox ( ) - > width ( ) ; }
virtual int height ( const TQListBox * ) const { return m_height ; }
private :
int m_height ;
} ;
ListBoxSeparator : : ListBoxSeparator ( int h ) : TQListBoxItem ( ) , m_height ( h )
{
// setText("-"); // not necessary, use TQString()
setCustomHighlighting ( true ) ;
setSelectable ( false ) ; // doesn't work here, so set it again after creating item
}
void ListBoxSeparator : : paint ( TQPainter * painter )
{
// TQRect r( 0, 0, width(listBox()), height(listBox()) );
painter - > setPen ( TQt : : gray ) ;
painter - > drawLine ( 0 , m_height / 2 + 1 , listBox ( ) - > width ( ) - 10 , m_height / 2 + 1 ) ;
}
//////////////////// EditableCheckListItem ////////////////////
class EditableCheckListItem : public TQCheckListItem
{
public :
EditableCheckListItem ( TQCheckListItem * tqparent , const TQString & text ) ;
virtual void paintCell ( TQPainter * p , const TQColorGroup & cg ,
int column , int width , int tqalignment ) ;
} ;
EditableCheckListItem : : EditableCheckListItem ( TQCheckListItem * tqparent , const TQString & text )
: TQCheckListItem ( tqparent , text , TQCheckListItem : : CheckBox )
{
}
void EditableCheckListItem : : paintCell ( TQPainter * p , const TQColorGroup & cg ,
int column , int width , int tqalignment )
{
if ( column = = 1 ) {
TQColorGroup colorgroup ( cg ) ;
TQListViewItem * item = dynamic_cast < TQListViewItem * > ( this ) ;
if ( item & & ( item - > text ( 1 ) = = i18n ( " <default> " ) | | item - > text ( 1 ) = = i18n ( " <empty> " ) ) ) {
colorgroup . setColor ( TQColorGroup : : Text , TQt : : gray ) ;
colorgroup . setColor ( TQColorGroup : : HighlightedText , TQt : : gray ) ;
}
TQCheckListItem : : paintCell ( p , colorgroup , column , width , TQt : : AlignHCenter ) ;
} else {
TQCheckListItem : : paintCell ( p , cg , column , width , tqalignment ) ;
}
}
//////////////////// QuickDocument class ////////////////////
QuickDocument : : QuickDocument ( KConfig * config , TQWidget * tqparent , const char * name , const TQString & caption ) : Wizard ( config , tqparent , name , caption )
{
KILE_DEBUG ( ) < < " ==QuickDocument::setupGUI()============ " < < endl ;
TQTabWidget * tabWidget = new TQTabWidget ( this ) ;
setMainWidget ( tabWidget ) ;
tabWidget - > addTab ( setupClassOptions ( tabWidget ) , i18n ( " Cla&ss Options " ) ) ;
tabWidget - > addTab ( setupPackages ( tabWidget ) , i18n ( " &Packages " ) ) ;
tabWidget - > addTab ( setupProperties ( tabWidget ) , i18n ( " &Document Properties " ) ) ;
// read config file
readConfig ( ) ;
}
QuickDocument : : ~ QuickDocument ( )
{ }
//////////////////// GUI ////////////////////
TQWidget * QuickDocument : : setupClassOptions ( TQTabWidget * tab )
{
KILE_DEBUG ( ) < < " \t setupClassOptions " < < endl ;
TQLabel * label ;
TQWidget * classOptions = new TQWidget ( tab ) ;
TQGridLayout * gl = new TQGridLayout ( classOptions , 6 , 4 , marginHint ( ) , spacingHint ( ) ) ;
gl - > setColStretch ( 1 , 1 ) ;
// Document classes
m_cbDocumentClass = new KComboBox ( classOptions ) ;
m_cbDocumentClass - > tqsetSizePolicy ( TQSizePolicy : : MinimumExpanding , TQSizePolicy : : Minimum ) ;
m_cbDocumentClass - > setDuplicatesEnabled ( false ) ;
// m_cbDocumentClass->listBox()->setVariableHeight(true);
gl - > addWidget ( m_cbDocumentClass , 0 , 1 ) ;
connect ( m_cbDocumentClass , TQT_SIGNAL ( activated ( int ) ) , this , TQT_SLOT ( slotDocumentClassChanged ( int ) ) ) ;
label = new TQLabel ( i18n ( " Doc&ument class: " ) , classOptions ) ;
gl - > addWidget ( label , 0 , 0 ) ;
label - > setBuddy ( m_cbDocumentClass ) ; label - > tqsetSizePolicy ( TQSizePolicy : : Maximum , TQSizePolicy : : Maximum ) ;
m_btnDocumentClassAdd = new KPushButton ( SmallIcon ( " edit_add " ) , " " , classOptions ) ;
TQWhatsThis : : add ( m_btnDocumentClassAdd , i18n ( " Add current text to this list " ) ) ;
gl - > addWidget ( m_btnDocumentClassAdd , 0 , 2 ) ;
connect ( m_btnDocumentClassAdd , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotDocumentClassAdd ( ) ) ) ;
m_btnDocumentClassDelete = new KPushButton ( SmallIcon ( " eraser " ) , " " , classOptions ) ;
TQWhatsThis : : add ( m_btnDocumentClassDelete , i18n ( " Remove current element from this list " ) ) ;
gl - > addWidget ( m_btnDocumentClassDelete , 0 , 3 ) ;
connect ( m_btnDocumentClassDelete , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotDocumentClassDelete ( ) ) ) ;
// Fontsize
m_cbTypefaceSize = new KComboBox ( classOptions ) ;
m_cbTypefaceSize - > setDuplicatesEnabled ( false ) ;
gl - > addWidget ( m_cbTypefaceSize , 1 , 1 ) ;
label = new TQLabel ( i18n ( " &Typeface size: " ) , classOptions ) ;
label - > setBuddy ( m_cbTypefaceSize ) ;
label - > tqsetSizePolicy ( TQSizePolicy : : Maximum , TQSizePolicy : : Maximum ) ;
gl - > addWidget ( label , 1 , 0 ) ;
m_btnTypefaceSizeAdd = new KPushButton ( SmallIcon ( " edit_add " ) , " " , classOptions ) ;
TQWhatsThis : : add ( m_btnTypefaceSizeAdd , i18n ( " Add current text to this list " ) ) ;
gl - > addWidget ( m_btnTypefaceSizeAdd , 1 , 2 ) ;
connect ( m_btnTypefaceSizeAdd , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotTypefaceSizeAdd ( ) ) ) ;
m_btnTypefaceSizeDelete = new KPushButton ( SmallIcon ( " eraser " ) , " " , classOptions ) ;
TQWhatsThis : : add ( m_btnTypefaceSizeDelete , i18n ( " Remove current element from this list " ) ) ;
gl - > addWidget ( m_btnTypefaceSizeDelete , 1 , 3 ) ;
connect ( m_btnTypefaceSizeDelete , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotTypefaceSizeDelete ( ) ) ) ;
// Papersize
m_cbPaperSize = new KComboBox ( classOptions ) ;
m_cbPaperSize - > tqsetSizePolicy ( TQSizePolicy : : MinimumExpanding , TQSizePolicy : : Minimum ) ;
m_cbPaperSize - > setDuplicatesEnabled ( false ) ;
gl - > addWidget ( m_cbPaperSize , 2 , 1 ) ;
m_lbPaperSize = new TQLabel ( i18n ( " Paper si&ze: " ) , classOptions ) ;
m_lbPaperSize - > setBuddy ( m_cbPaperSize ) ;
m_lbPaperSize - > tqsetSizePolicy ( TQSizePolicy : : Maximum , TQSizePolicy : : Maximum ) ;
gl - > addWidget ( m_lbPaperSize , 2 , 0 ) ;
m_btnPaperSizeAdd = new KPushButton ( SmallIcon ( " edit_add " ) , " " , classOptions ) ;
TQWhatsThis : : add ( m_btnPaperSizeAdd , i18n ( " Add current text to this list " ) ) ;
gl - > addWidget ( m_btnPaperSizeAdd , 2 , 2 ) ;
connect ( m_btnPaperSizeAdd , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotPaperSizeAdd ( ) ) ) ;
m_btnPaperSizeDelete = new KPushButton ( SmallIcon ( " eraser " ) , " " , classOptions ) ;
TQWhatsThis : : add ( m_btnPaperSizeDelete , i18n ( " Remove current element from this list " ) ) ;
gl - > addWidget ( m_btnPaperSizeDelete , 2 , 3 ) ;
connect ( m_btnPaperSizeDelete , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotPaperSizeDelete ( ) ) ) ;
// Encoding
m_cbEncoding = new KComboBox ( classOptions ) ;
m_cbEncoding - > tqsetSizePolicy ( TQSizePolicy : : MinimumExpanding , TQSizePolicy : : Minimum ) ;
m_cbEncoding - > setDuplicatesEnabled ( false ) ;
gl - > addWidget ( m_cbEncoding , 3 , 1 ) ;
label = new TQLabel ( i18n ( " E&ncoding: " ) , classOptions ) ;
label - > setBuddy ( m_cbEncoding ) ;
label - > tqsetSizePolicy ( TQSizePolicy : : Maximum , TQSizePolicy : : Maximum ) ;
gl - > addWidget ( label , 3 , 0 ) ;
// Class Options
m_lvClassOptions = new TQListView ( classOptions ) ;
m_lvClassOptions - > addColumn ( i18n ( " Option " ) ) ;
m_lvClassOptions - > addColumn ( i18n ( " Description " ) ) ;
m_lvClassOptions - > setAllColumnsShowFocus ( true ) ;
gl - > addMultiCellWidget ( m_lvClassOptions , 4 , 4 , 1 , 3 ) ;
connect ( m_lvClassOptions , TQT_SIGNAL ( selectionChanged ( ) ) ,
this , TQT_SLOT ( slotEnableButtons ( ) ) ) ;
connect ( m_lvClassOptions , TQT_SIGNAL ( doubleClicked ( TQListViewItem * , const TQPoint & , int ) ) ,
this , TQT_SLOT ( slotOptionDoubleClicked ( TQListViewItem * , const TQPoint & , int ) ) ) ;
label = new TQLabel ( i18n ( " Cl&ass options: " ) , classOptions ) ;
label - > setBuddy ( m_lvClassOptions ) ;
label - > tqsetSizePolicy ( TQSizePolicy : : Maximum , TQSizePolicy : : MinimumExpanding ) ;
label - > tqsetAlignment ( TQt : : AlignTop ) ;
gl - > addWidget ( label , 4 , 0 ) ;
// button
TQWidget * frame = new TQWidget ( classOptions ) ;
TQHBoxLayout * hl = new TQHBoxLayout ( frame , 0 , spacingHint ( ) ) ;
//hl->addStretch(1);
gl - > addMultiCellWidget ( frame , 5 , 5 , 1 , 3 , TQt : : AlignCenter ) ;
m_btnClassOptionsAdd = new KPushButton ( SmallIcon ( " edit_add " ) , i18n ( " &Add... " ) , frame ) ;
TQWhatsThis : : add ( m_btnClassOptionsAdd , i18n ( " Add a new class option " ) ) ;
hl - > addWidget ( m_btnClassOptionsAdd ) ;
connect ( m_btnClassOptionsAdd , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotClassOptionAdd ( ) ) ) ;
m_btnClassOptionsEdit = new KPushButton ( SmallIcon ( " edit " ) , i18n ( " Ed&it... " ) , frame ) ;
TQWhatsThis : : add ( m_btnClassOptionsEdit , i18n ( " Edit the current class option " ) ) ;
hl - > addWidget ( m_btnClassOptionsEdit ) ;
connect ( m_btnClassOptionsEdit , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotClassOptionEdit ( ) ) ) ;
m_btnClassOptionsDelete = new KPushButton ( SmallIcon ( " eraser " ) , i18n ( " De&lete " ) , frame ) ;
TQWhatsThis : : add ( m_btnClassOptionsDelete , i18n ( " Remove the current class option " ) ) ;
hl - > addWidget ( m_btnClassOptionsDelete ) ;
connect ( m_btnClassOptionsDelete , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotClassOptionDelete ( ) ) ) ;
return classOptions ;
}
TQWidget * QuickDocument : : setupPackages ( TQTabWidget * tab )
{
KILE_DEBUG ( ) < < " \t setupPackages " < < endl ;
TQWidget * packages = new TQWidget ( tab ) ;
TQVBoxLayout * vl = new TQVBoxLayout ( packages , marginHint ( ) , spacingHint ( ) ) ;
TQLabel * label = new TQLabel ( i18n ( " LaTe&X packages: " ) , packages ) ;
vl - > addWidget ( label ) ;
m_lvPackages = new TQListView ( packages ) ;
vl - > addWidget ( m_lvPackages ) ;
m_lvPackages - > setRootIsDecorated ( true ) ;
m_lvPackages - > addColumn ( i18n ( " Package " ) ) ;
m_lvPackages - > addColumn ( i18n ( " Value " ) ) ;
m_lvPackages - > addColumn ( i18n ( " Description " ) ) ;
m_lvPackages - > setAllColumnsShowFocus ( true ) ;
label - > setBuddy ( m_lvPackages ) ;
connect ( m_lvPackages , TQT_SIGNAL ( clicked ( TQListViewItem * ) ) ,
this , TQT_SLOT ( slotCheckParent ( TQListViewItem * ) ) ) ;
connect ( m_lvPackages , TQT_SIGNAL ( spacePressed ( TQListViewItem * ) ) ,
this , TQT_SLOT ( slotCheckParent ( TQListViewItem * ) ) ) ;
connect ( m_lvPackages , TQT_SIGNAL ( selectionChanged ( ) ) ,
this , TQT_SLOT ( slotEnableButtons ( ) ) ) ;
connect ( m_lvPackages , TQT_SIGNAL ( doubleClicked ( TQListViewItem * , const TQPoint & , int ) ) ,
this , TQT_SLOT ( slotPackageDoubleClicked ( TQListViewItem * , const TQPoint & , int ) ) ) ;
TQWidget * frame = new TQWidget ( packages ) ;
vl - > addWidget ( frame ) ;
TQHBoxLayout * hl = new TQHBoxLayout ( frame , 0 , spacingHint ( ) ) ;
hl - > addStretch ( 1 ) ;
m_btnPackagesAdd = new KPushButton ( SmallIcon ( " edit_add " ) , " &Add Package... " , frame ) ;
TQWhatsThis : : add ( m_btnPackagesAdd , i18n ( " Add a new package " ) ) ;
connect ( m_btnPackagesAdd , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotPackageAdd ( ) ) ) ;
hl - > addWidget ( m_btnPackagesAdd ) ;
m_btnPackagesAddOption = new KPushButton ( SmallIcon ( " edit_add " ) , i18n ( " Add Op&tion... " ) , frame ) ;
TQWhatsThis : : add ( m_btnPackagesAddOption , i18n ( " Add a new package option " ) ) ;
connect ( m_btnPackagesAddOption , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotPackageAddOption ( ) ) ) ;
hl - > addWidget ( m_btnPackagesAddOption ) ;
m_btnPackagesEdit = new KPushButton ( SmallIcon ( " edit " ) , " Ed&it... " , frame ) ;
TQWhatsThis : : add ( m_btnPackagesEdit , i18n ( " Edit the current package option " ) ) ;
connect ( m_btnPackagesEdit , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotPackageEdit ( ) ) ) ;
hl - > addWidget ( m_btnPackagesEdit ) ;
m_btnPackagesDelete = new KPushButton ( SmallIcon ( " eraser " ) , i18n ( " De&lete " ) , frame ) ;
TQWhatsThis : : add ( m_btnPackagesDelete , i18n ( " Remove the current package option " ) ) ;
connect ( m_btnPackagesDelete , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotPackageDelete ( ) ) ) ;
hl - > addWidget ( m_btnPackagesDelete ) ;
m_btnPackagesReset = new KPushButton ( SmallIcon ( " reload " ) , i18n ( " &Reset to Defaults " ) , frame ) ;
TQWhatsThis : : add ( m_btnPackagesReset , i18n ( " Reset to the default list of packages " ) ) ;
connect ( m_btnPackagesReset , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( slotPackageReset ( ) ) ) ;
hl - > addWidget ( m_btnPackagesReset ) ;
hl - > addStretch ( 1 ) ;
return packages ;
}
TQWidget * QuickDocument : : setupProperties ( TQTabWidget * tab )
{
KILE_DEBUG ( ) < < " \t setupProperties " < < endl ;
TQLabel * label ;
TQWidget * personalInfo = new TQWidget ( tab ) ;
TQGridLayout * gl = new TQGridLayout ( personalInfo , 4 , 2 , marginHint ( ) , spacingHint ( ) ) ;
gl - > setRowStretch ( gl - > numRows ( ) - 1 , 1 ) ;
m_leAuthor = new KLineEdit ( personalInfo ) ;
gl - > addWidget ( m_leAuthor , 0 , 1 ) ;
label = new TQLabel ( i18n ( " &Author: " ) , personalInfo ) ;
gl - > addWidget ( label , 0 , 0 ) ;
label - > setBuddy ( m_leAuthor ) ;
m_leTitle = new KLineEdit ( personalInfo ) ;
gl - > addWidget ( m_leTitle , 1 , 1 ) ;
label = new TQLabel ( i18n ( " &Title: " ) , personalInfo ) ;
gl - > addWidget ( label , 1 , 0 ) ;
label - > setBuddy ( m_leTitle ) ;
m_leDate = new KLineEdit ( personalInfo ) ;
gl - > addWidget ( m_leDate , 2 , 1 ) ;
label = new TQLabel ( i18n ( " Dat&e: " ) , personalInfo ) ;
gl - > addWidget ( label , 2 , 0 ) ;
label - > setBuddy ( m_leDate ) ;
// set current date
m_leDate - > setText ( KGlobal : : locale ( ) - > formatDate ( TQDate : : tqcurrentDate ( ) , true ) ) ;
// For KDE4:
//m_leDate->setText( KGlobal::locale()->formatDate(TQDate::tqcurrentDate(), KLocale::ShortDate) );
return personalInfo ;
}
//////////////////// read configuration ////////////////////
void QuickDocument : : readConfig ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::readConfig()============ " < < endl ;
// read config for document class
readDocumentClassConfig ( ) ;
// init the current document class
initDocumentClass ( ) ;
// read config for packages
readPackagesConfig ( ) ;
initHyperref ( ) ;
// read author
m_leAuthor - > setText ( KileConfig : : author ( ) ) ;
}
//////////////////// write configuration ////////////////////
void QuickDocument : : writeConfig ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::writeConfig()============ " < < endl ;
// write document class to config file
writeDocumentClassConfig ( ) ;
// write packages to config file
writePackagesConfig ( ) ;
// set author
KileConfig : : setAuthor ( m_leAuthor - > text ( ) ) ;
}
////////////////////////////// document class tab //////////////////////////////
void QuickDocument : : readDocumentClassConfig ( )
{
KILE_DEBUG ( ) < < " \t read config: document class " < < endl ;
// read standard options
m_userClasslist = KileConfig : : userClasses ( ) ;
m_currentClass = KileConfig : : documentClass ( ) ;
m_currentEncoding = KileConfig : : encoding ( ) ;
// init standard classes
TQString stdFontsize = " 10pt,11pt,12pt " ;
TQString stdPapersize = " a4paper,a5paper,b5paper,executivepaper,legalpaper,letterpaper " ;
TQString beamerThemes = " bars;boxes;classic;lined;plain;sidebar;sidebar (dark);sidebar (tab); "
" sidebar (dark,tab);shadow;split;tree;tree (bar) " ;
initStandardClass ( " article " , stdFontsize , stdPapersize ,
" 10pt,letterpaper,oneside,onecolumn,final " ,
KileConfig : : optionsArticle ( ) ) ;
initStandardClass ( " book " , stdFontsize , stdPapersize ,
" 10pt,letterpaper,twoside,onecolumn,final,openright " ,
KileConfig : : optionsBook ( ) ) ;
initStandardClass ( " letter " , stdFontsize , stdPapersize ,
" 10pt,letterpaper,oneside,onecolumn,final " ,
KileConfig : : optionsLetter ( ) ) ;
initStandardClass ( " report " , stdFontsize , stdPapersize ,
" 10pt,letterpaper,oneside,onecolumn,final,openany " ,
KileConfig : : optionsReport ( ) ) ;
initStandardClass ( " scrartcl " , stdFontsize , stdPapersize ,
" 11pt,a4paper,abstractoff,bigheadings,final,headnosepline, "
" footnosepline,listsindent,onelinecaption,notitlepage,onecolumn, "
" oneside,openany,parindent,tablecaptionbelow,tocindent " ,
KileConfig : : optionsScrartcl ( ) ) ;
initStandardClass ( " scrbook " , stdFontsize , stdPapersize ,
" 11pt,a4paper,bigheadings,final,headnosepline,footnosepline, "
" listsindent,nochapterprefix,onelinecaption,onecolumn, "
" openright,parindent,tablecaptionbelow,titlepage,tocindent,twoside " ,
KileConfig : : optionsScrbook ( ) ) ;
initStandardClass ( " scrreprt " , stdFontsize , stdPapersize ,
" 11pt,a4paper,abstractoff,bigheadings,final,headnosepline, "
" footnosepline,listsindent,nochapterprefix,onelinecaption,onecolumn, "
" oneside,openany,parindent,tablecaptionbelow,titlepage,tocindent " ,
KileConfig : : optionsScrreprt ( ) ) ;
initStandardClass ( " prosper " , TQString ( ) , TQString ( ) ,
" final,slideBW,total,nocolorBG,ps,noaccumulate,ps2pdf " ,
KileConfig : : optionsProsper ( ) ) ;
initStandardClass ( " beamer " , " 8pt,9pt,10pt,11pt,12pt,14pt,17pt,20pt " , beamerThemes ,
" 11pt,blue,notes=show,sans,slidescentered " ,
KileConfig : : optionsBeamer ( ) ) ;
// init all user classes
for ( uint i = 0 ; i < m_userClasslist . count ( ) ; + + i )
{
KILE_DEBUG ( ) < < " \t init user class: " < < m_userClasslist [ i ] < < endl ;
TQStringList list ;
// read dour default entries for this user class
m_config - > setGroup ( TQString ( " QuickDocument/ " ) + m_userClasslist [ i ] ) ;
list . append ( m_config - > readEntry ( " fontsizesList " ) ) ;
list . append ( m_config - > readEntry ( " pagesizesList " ) ) ;
list . append ( m_config - > readEntry ( " defaultOptions " ) ) ;
list . append ( m_config - > readEntry ( " selectedOptions " ) ) ;
// now read all user defined options
TQStringList options = TQStringList : : split ( " , " , m_config - > readEntry ( " options " ) ) ;
for ( uint j = 0 ; j < options . count ( ) ; + + j ) {
list . append ( options [ j ] + " => " + m_config - > readEntry ( options [ j ] ) ) ;
}
// save all information of this class into the documentClass-dictionary
m_dictDocumentClasses [ m_userClasslist [ i ] ] = list ;
}
// set classes combobox (standard and user defined classes)
fillDocumentClassCombobox ( ) ;
// set encoding combobox
fillCombobox ( m_cbEncoding ,
" ansinew,applemac,ascii,cp1252,cp1250,cp1251,cp1257,cp437,cp437de,cp850,cp858, "
" cp852,cp865,decmulti,koi8-r,latin1,latin2,latin3,latin4,latin5,latin9,latin10,next,utf8,utf8x,utf-8,utfcyr " ,
m_currentEncoding ) ;
}
void QuickDocument : : fillDocumentClassCombobox ( )
{
TQString stdClasses = " article,book,letter,report,-,scrartcl,scrbook,scrreprt,- " ;
TQString stdUserClasses = " beamer,prosper " ;
// set classes combobox (standard and user defined classes)
TQStringList classlist = TQStringList : : split ( " , " , stdUserClasses ) ;
for ( uint i = 0 ; i < m_userClasslist . count ( ) ; + + i )
classlist . append ( m_userClasslist [ i ] ) ;
classlist . sort ( ) ;
fillCombobox ( m_cbDocumentClass , stdClasses + ' , ' + classlist . join ( " , " ) , m_currentClass ) ;
}
void QuickDocument : : writeDocumentClassConfig ( )
{
KILE_DEBUG ( ) < < " \t write config: document class " < < endl ;
// first delete all marked document classes
for ( uint i = 0 ; i < m_deleteDocumentClasses . count ( ) ; + + i ) {
KILE_DEBUG ( ) < < " \t delete class: " < < m_deleteDocumentClasses [ i ] < < endl ;
m_config - > deleteGroup ( TQString ( " QuickDocument/ " ) + m_deleteDocumentClasses [ i ] ) ;
}
// write document classes and encoding
TQStringList userclasses ;
for ( int i = 0 ; i < m_cbDocumentClass - > count ( ) ; + + i ) {
if ( ! m_cbDocumentClass - > text ( i ) . isEmpty ( ) & & ! isStandardClass ( m_cbDocumentClass - > text ( i ) ) ) {
userclasses . append ( m_cbDocumentClass - > text ( i ) ) ;
}
}
KileConfig : : setUserClasses ( userclasses ) ;
KileConfig : : setDocumentClass ( m_cbDocumentClass - > currentText ( ) ) ;
KileConfig : : setEncoding ( m_cbEncoding - > currentText ( ) ) ;
// write checked options of standard classes
KILE_DEBUG ( ) < < " \t write standard classes " < < endl ;
KileConfig : : setOptionsArticle ( m_dictDocumentClasses [ " article " ] [ qd_SelectedOptions ] ) ;
KileConfig : : setOptionsBook ( m_dictDocumentClasses [ " book " ] [ qd_SelectedOptions ] ) ;
KileConfig : : setOptionsLetter ( m_dictDocumentClasses [ " letter " ] [ qd_SelectedOptions ] ) ;
KileConfig : : setOptionsReport ( m_dictDocumentClasses [ " report " ] [ qd_SelectedOptions ] ) ;
KileConfig : : setOptionsScrartcl ( m_dictDocumentClasses [ " scrartcl " ] [ qd_SelectedOptions ] ) ;
KileConfig : : setOptionsScrbook ( m_dictDocumentClasses [ " scrbook " ] [ qd_SelectedOptions ] ) ;
KileConfig : : setOptionsScrreprt ( m_dictDocumentClasses [ " scrreprt " ] [ qd_SelectedOptions ] ) ;
KileConfig : : setOptionsProsper ( m_dictDocumentClasses [ " prosper " ] [ qd_SelectedOptions ] ) ;
KileConfig : : setOptionsBeamer ( m_dictDocumentClasses [ " beamer " ] [ qd_SelectedOptions ] ) ;
// write config of user packages
TQRegExp reg ( " ( \\ S+) \ \ s + = > \ \ s + ( . * ) " ) ;
for ( uint i = 0 ; i < userclasses . count ( ) ; + + i ) {
// get the stringlist with all information
KILE_DEBUG ( ) < < " \t write user class: " < < userclasses [ i ] < < endl ;
TQStringList list = m_dictDocumentClasses [ userclasses [ i ] ] ;
// write the config group and the default entries
m_config - > setGroup ( TQString ( " QuickDocument/ " ) + userclasses [ i ] ) ;
m_config - > writeEntry ( " fontsizesList " , list [ qd_Fontsizes ] ) ;
m_config - > writeEntry ( " pagesizesList " , list [ qd_Papersizes ] ) ;
m_config - > writeEntry ( " defaultOptions " , list [ qd_DefaultOptions ] ) ;
m_config - > writeEntry ( " selectedOptions " , list [ qd_SelectedOptions ] ) ;
// write user defined options
TQString options ;
for ( uint j = qd_OptionsStart ; j < list . count ( ) ; + + j ) {
int pos = reg . search ( list [ j ] ) ;
if ( pos ! = - 1 ) {
m_config - > writeEntry ( reg . cap ( 1 ) , reg . cap ( 2 ) ) ;
if ( ! options . isEmpty ( ) )
options + = ' , ' ;
options + = reg . cap ( 1 ) ;
}
}
m_config - > writeEntry ( " options " , options ) ;
}
}
void QuickDocument : : initDocumentClass ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::initDocumentClass()============ " < < endl ;
KILE_DEBUG ( ) < < " \t set class: " < < m_currentClass < < endl ;
// get the stringlist of this class with all information
TQStringList classlist = m_dictDocumentClasses [ m_currentClass ] ;
// First of all, we have to set the defaultOptions-dictionary and the
// selectedOptions-dictionary for this class, before inserting options
// into the listview. The function setClassOptions() will look
// into both dictionaries to do some extra work.
setDefaultClassOptions ( classlist [ qd_DefaultOptions ] ) ;
setSelectedClassOptions ( classlist [ qd_SelectedOptions ] ) ;
// set comboboxes for fontsizes and papersizes
fillCombobox ( m_cbTypefaceSize , classlist [ qd_Fontsizes ] , m_currentFontsize ) ;
fillCombobox ( m_cbPaperSize , classlist [ qd_Papersizes ] , m_currentPapersize ) ;
// now we are ready to set the class options
if ( isStandardClass ( m_currentClass ) ) {
TQStringList optionlist ;
initStandardOptions ( m_currentClass , optionlist ) ;
setClassOptions ( optionlist , 0 ) ;
} else {
setClassOptions ( classlist , qd_OptionsStart ) ;
}
// there is no papersize with class beamer, but a theme
if ( m_currentClass = = " beamer " )
m_lbPaperSize - > setText ( i18n ( " &Theme: " ) ) ;
else
m_lbPaperSize - > setText ( i18n ( " Paper si&ze: " ) ) ;
// enable/disable buttons to add or delete entries
slotEnableButtons ( ) ;
}
void QuickDocument : : initStandardClass ( const TQString & classname ,
const TQString & fontsize , const TQString & papersize ,
const TQString & defaultoptions , const TQString & selectedoptions )
{
KILE_DEBUG ( ) < < " \t init standard class: " < < classname < < endl ;
// remember that this is a standard class
m_dictStandardClasses [ classname ] = true ;
// save all entries
TQStringList list ;
list < < fontsize < < papersize < < defaultoptions < < selectedoptions ;
// save in documentClass-dictionary
m_dictDocumentClasses [ classname ] = list ;
}
// build all option for the current standard class
void QuickDocument : : initStandardOptions ( const TQString & classname , TQStringList & optionlist )
{
// build the bitcode for all options of this class
int options ;
if ( classname = = " article " )
options = qd_Base + qd_Article ;
else if ( classname = = " book " )
options = qd_Base + qd_Article + qd_BookReport ;
else if ( classname = = " letter " )
options = qd_Base ;
else if ( classname = = " report " )
options = qd_Base + qd_Article + qd_BookReport ;
else if ( classname = = " scrartcl " )
options = qd_Base + qd_Article + qd_KomaArticle + qd_KomaAbstract ;
else if ( classname = = " scrbook " )
options = qd_Base + qd_Article + qd_BookReport + qd_KomaArticle + qd_KomaBookReport ;
else if ( classname = = " scrreprt " )
options = qd_Base + qd_Article + qd_BookReport + qd_KomaArticle + qd_KomaAbstract + qd_KomaBookReport ;
else if ( classname = = " prosper " )
options = qd_Prosper ;
else if ( classname = = " beamer " )
options = qd_Beamer ;
else
return ;
// insert all options into the list
if ( options & qd_Base ) {
optionlist
< < TQString ( " landscape => " ) + i18n ( " Sets the document's orientation to landscape " )
< < TQString ( " oneside => " ) + i18n ( " Margins are set for single side output " )
< < TQString ( " twoside => " ) + i18n ( " Left and right pages differ in page margins " )
< < TQString ( " draft => " ) + i18n ( " Marks \" overfull hboxes \" on the output with black boxes " )
< < TQString ( " final => " ) + i18n ( " No special marks for \" overfull hboxes \" on the output " )
< < TQString ( " leqno => " ) + i18n ( " Puts formula numbers on the left side " )
< < TQString ( " fleqn => " ) + i18n ( " Aligns formulas on the left side " )
;
}
if ( options & qd_Article ) {
optionlist
< < TQString ( " titlepage => " ) + i18n ( " Puts title and abstract on an extra page " )
< < TQString ( " notitlepage => " ) + i18n ( " Puts title and abstract on the same page as the text " )
< < TQString ( " onecolumn => " ) + i18n ( " Puts the text in one column " )
< < TQString ( " twocolumn => " ) + i18n ( " Puts the text in two columns " )
< < TQString ( " openbib => " ) + i18n ( " Formats the bibliography in open style " )
;
}
if ( options & qd_BookReport ) {
optionlist
< < TQString ( " openany => " ) + i18n ( " Chapters may start on top of every page " )
< < TQString ( " openright => " ) + i18n ( " Chapters may only start on top of right pages " )
;
}
if ( options & qd_KomaArticle ) {
optionlist
< < TQString ( " headinclude => " ) + i18n ( " Cause the header to be counted as text " )
< < TQString ( " headexclude => " ) + i18n ( " Cause the header to be counted as border " )
< < TQString ( " footinclude => " ) + i18n ( " Cause the footer to be counted as text " )
< < TQString ( " footexclude => " ) + i18n ( " Cause the footer to be counted as border " )
< < TQString ( " mpinclude => " ) + i18n ( " Cause the margin-note to be counted to the text body " )
< < TQString ( " mpexclude => " ) + i18n ( " The normal margin is used for the margin-note area " )
< < TQString ( " dvips => " ) + i18n ( " Writes the paper size as a special into the DVI-file " )
< < TQString ( " pdftex => " ) + i18n ( " Writes the paper size into the pdftex page register " )
< < TQString ( " pagesize => " ) + i18n ( " Uses the correct mechanism with PDF- or DVI-file " )
< < TQString ( " cleardoubleempty => " ) + i18n ( " Enables the default for an empty left page " )
< < TQString ( " cleardoubleplain => " ) + i18n ( " An empty left page will set with the plain-pagestyle " )
< < TQString ( " cleardoublestandard => " ) + i18n ( " An empty left page will set with the empty-pagestyle " )
< < TQString ( " headsepline => " ) + i18n ( " Use a line to separate the header from the text body " )
< < TQString ( " headnosepline => " ) + i18n ( " Use no line to separate the header from the text body " )
< < TQString ( " footsepline => " ) + i18n ( " Use a line to separate the footer from the text body " )
< < TQString ( " footnosepline => " ) + i18n ( " Use no line to separate the footer from the text body " )
< < TQString ( " parskip => " ) + i18n ( " Normal paragraph spacing of one line " )
< < TQString ( " parskip- => " ) + i18n ( " Normal spacing, at least 1/3 of the last line is free " )
< < TQString ( " parskip+ => " ) + i18n ( " Normal spacing, at least 1/4 of the last line is free " )
< < TQString ( " parskip* => " ) + i18n ( " Normal spacing, no special provision for the last line " )
< < TQString ( " halfparskip => " ) + i18n ( " Paragraph spacing of half a line " )
< < TQString ( " halfparskip- => " ) + i18n ( " Spacing 1/2 line, at least 1/3 of the last line is free " )
< < TQString ( " halfparskip+ => " ) + i18n ( " Spacing 1/2 line, at least 1/4 of the last line is free " )
< < TQString ( " halfparskip* => " ) + i18n ( " Spacing 1/2 line, no special provision for the last line " )
< < TQString ( " parindent => " ) + i18n ( " No spacing between paragraphs, indent the first line by 1 em " )
< < TQString ( " onelinecaption => " ) + i18n ( " One-line captions are centered, multi-line left-justified " )
< < TQString ( " noonelinecaption => " ) + i18n ( " No special handling of one-line captions " )
< < TQString ( " bigheading => " ) + i18n ( " Normal great title font sizes " )
< < TQString ( " normalheadings => " ) + i18n ( " Small font sizes for titles " )
< < TQString ( " smallheadings => " ) + i18n ( " Even smaller font sizes for titles " )
< < TQString ( " liststotoc => " ) + i18n ( " Include lists of figures and tables in the TOC " )
< < TQString ( " bibtotoc => " ) + i18n ( " Include the bibliography in the TOC " )
< < TQString ( " idxtotoc => " ) + i18n ( " Include the index in the TOC " )
< < TQString ( " liststotocnumbered => " ) + i18n ( " Number the lists of figures and tables in the TOC " )
< < TQString ( " bibtotocnumbered => " ) + i18n ( " Number the bibliography in the TOC " )
< < TQString ( " tocleft => " ) + i18n ( " All numbers and titles are set in a left-justified column " )
< < TQString ( " tocindent => " ) + i18n ( " Different sectional units have different indentations " )
< < TQString ( " listsleft => " ) + i18n ( " All numbers and captions are set in a left-justified column " )
< < TQString ( " listsindent => " ) + i18n ( " All Numbers uses a fixed space " )
< < TQString ( " pointednumbers => " ) + i18n ( " Numbering of sectional units have a point at the end " )
< < TQString ( " pointlessnumbers => " ) + i18n ( " Numbering of sectional units have no point at the end " )
< < TQString ( " tablecaptionabove => " ) + i18n ( " Caption command acts like \\ captionabove " )
< < TQString ( " tablecaptionbelow => " ) + i18n ( " Caption command acts like \\ captionbelow " )
< < TQString ( " origlongtable => " ) + i18n ( " Captions of the longtable package should not be redefined " )
;
}
if ( options & qd_KomaBookReport ) {
optionlist
< < TQString ( " chapterprefix => " ) + i18n ( " Use a separate line for the chapter number " )
< < TQString ( " nochapterprefix => " ) + i18n ( " Use the same line for the chapter number and title " )
< < TQString ( " appendixprefix => " ) + i18n ( " Use a separate line for the appendix name " )
< < TQString ( " noappendixprefix => " ) + i18n ( " No separate line for the appendix name " )
;
}
if ( options & qd_KomaAbstract ) {
optionlist
< < TQString ( " abstracton => " ) + i18n ( " Include the abstract's title " )
< < TQString ( " abstractoff => " ) + i18n ( " Exclude the abstract's title " )
;
}
if ( options & qd_Prosper ) {
optionlist
< < TQString ( " draft => " ) + i18n ( " The file is compiled in draft mode " )
< < TQString ( " final => " ) + i18n ( " The file is compiled in final mode " )
< < TQString ( " slideColor => " ) + i18n ( " Slides will use many colors " )
< < TQString ( " slideBW => " ) + i18n ( " Slides will use a restricted set of colors " )
< < TQString ( " total => " ) + i18n ( " Display the number of the current slide and the total number " )
< < TQString ( " nototal => " ) + i18n ( " Display only the number of the current slide " )
< < TQString ( " nocolorBG => " ) + i18n ( " The background of the slide is always white " )
< < TQString ( " colorBG => " ) + i18n ( " The color of the background depends on the current style " )
< < TQString ( " ps => " ) + i18n ( " The LaTeX file is compiled to produce a PostScript file " )
< < TQString ( " pdf => " ) + i18n ( " The LaTeX file is compiled to produce a PDF file " )
< < TQString ( " accumulate => " ) + i18n ( " Some macros interpret their argument in ps mode " )
< < TQString ( " noaccumulate => " ) + i18n ( " Some macros do not interpret their argument in ps mode " )
< < TQString ( " distiller => " ) + i18n ( " The PS file is to be translated into a PDF file using Adobe Distiller " )
< < TQString ( " YandY => " ) + i18n ( " The LaTeX file is to be processed with YandY LaTeX " )
< < TQString ( " ps2pdf => " ) + i18n ( " The PS file is to be translated into a PDF file using ps2pdf " )
< < TQString ( " vtex => " ) + i18n ( " The LaTeX file is to be processed with MicroPress VTeX " )
< < TQString ( " noFooter => " ) + i18n ( " Do not add any caption at the bottom of the slides " )
;
}
if ( options & qd_Beamer ) {
optionlist
< < TQString ( " slidestop => " ) + i18n ( " Place text of slides at the (vertical) top of the slides " )
< < TQString ( " slidescentered => " ) + i18n ( " Place text of slides at the (vertical) center of the slides " )
< < TQString ( " draft => " ) + i18n ( " Headlines, footlines, and sidebars are replaced by gray rectangles " )
< < TQString ( " compress => " ) + i18n ( " Make all navigation bars as small as possible " )
< < TQString ( " usepdftitle=false => " ) + i18n ( " Suppresses generation of some entries in the pdf information " )
< < TQString ( " notheorems => " ) + i18n ( " Switches off the definition of default blocks like theorem " )
< < TQString ( " noamsthm => " ) + i18n ( " Does not load amsthm and amsmath " )
< < TQString ( " CJK => " ) + i18n ( " Needed when using the CJK package for Asian fonts " )
< < TQString ( " sans => " ) + i18n ( " Use a sans-serif font during the presentation " )
< < TQString ( " serif => " ) + i18n ( " Use a serif font during the presentation " )
< < TQString ( " mathsans => " ) + i18n ( " Override the math font to be a sans-serif font " )
< < TQString ( " mathserif => " ) + i18n ( " Override the math font to be a serif font " )
< < TQString ( " professionalfont => " ) + i18n ( " Deactivate internal font replacements for math text " )
< < TQString ( " handout => " ) + i18n ( " Create a PDF handout " )
< < TQString ( " trans => " ) + i18n ( " For PDF transparency " )
< < TQString ( " blue => " ) + i18n ( " All structure elements are typeset in blue " )
< < TQString ( " red => " ) + i18n ( " All structure elements are typeset in red " )
< < TQString ( " blackandwhite => " ) + i18n ( " All structure elements are typeset in black and white " )
< < TQString ( " brown => " ) + i18n ( " All structure elements are typeset in brown " )
< < TQString ( " notes=hide => " ) + i18n ( " Notes are not shown " )
< < TQString ( " notes=show => " ) + i18n ( " Include notes in the output file " )
< < TQString ( " notes=only => " ) + i18n ( " Include only notes and suppress frames " )
;
}
}
// check for a standard class
bool QuickDocument : : isStandardClass ( const TQString & classname )
{
return m_dictStandardClasses . tqcontains ( classname ) ;
}
// check for a default option
bool QuickDocument : : isDefaultClassOption ( const TQString & option )
{
return m_currentDefaultOptions . tqcontains ( option ) ;
}
// check for an user option
bool QuickDocument : : isSelectedClassOption ( const TQString & option )
{
return m_currentSelectedOptions . tqcontains ( option ) ;
}
// insert all default options of the current class into the defaultOptions-dictionary
void QuickDocument : : setDefaultClassOptions ( const TQString & defaultoptions )
{
TQStringList list = TQStringList : : split ( " , " , defaultoptions ) ;
m_currentDefaultOptions . clear ( ) ;
for ( uint i = 0 ; i < list . count ( ) ; + + i ) {
if ( ! list [ i ] . isEmpty ( ) )
m_currentDefaultOptions [ list [ i ] ] = true ;
}
}
// insert all checked options of the current class into the selectedOptions-dictionary
void QuickDocument : : setSelectedClassOptions ( const TQString & selectedoptions )
{
KILE_DEBUG ( ) < < " \t set options: " < < selectedoptions < < endl ;
TQStringList list = TQStringList : : split ( " , " , selectedoptions ) ;
uint nlist = list . count ( ) ;
m_currentFontsize = ( nlist > = 1 ) ? list [ 0 ] : " " ;
m_currentPapersize = ( nlist > = 2 ) ? list [ 1 ] : " " ;
m_currentSelectedOptions . clear ( ) ;
for ( uint i = 0 ; i < nlist ; + + i ) {
if ( ! list [ i ] . isEmpty ( ) )
m_currentSelectedOptions [ list [ i ] ] = true ;
}
}
// show all options of the current class
// - split this string into option and description (option => description)
// - if the option is in the defaultOptions-dictionary, add 'default'
// - if the option is in the selectedOptions-dictionary, set the 'checked' symbol
void QuickDocument : : setClassOptions ( const TQStringList & list , uint start )
{
TQRegExp reg ( " ( \\ S+) \ \ s + = > \ \ s + ( . * ) " ) ;
m_lvClassOptions - > clear ( ) ;
for ( uint i = start ; i < list . count ( ) ; + + i ) {
int pos = reg . search ( list [ i ] ) ;
if ( pos ! = - 1 ) {
TQCheckListItem * cli = new TQCheckListItem ( m_lvClassOptions , reg . cap ( 1 ) , TQCheckListItem : : CheckBox ) ;
// see if it is a default option
if ( isDefaultClassOption ( reg . cap ( 1 ) ) )
cli - > setText ( 1 , reg . cap ( 2 ) + " [default] " ) ;
else
cli - > setText ( 1 , reg . cap ( 2 ) ) ;
// check it if this option is set by th user
if ( isSelectedClassOption ( reg . cap ( 1 ) ) )
cli - > setOn ( true ) ;
}
}
}
// get all options of the current class as a comma separated list
// - first entry: always the current fontsize
// - second entry: always the current papersize
// - followed by all other checked options
TQString QuickDocument : : getClassOptions ( )
{
TQString fontsize = stripDefault ( m_cbTypefaceSize - > currentText ( ) ) ;
TQString papersize = stripDefault ( m_cbPaperSize - > currentText ( ) ) ;
TQString options = fontsize + ' , ' + papersize ;
for ( TQListViewItem * cur = m_lvClassOptions - > firstChild ( ) ; cur ; cur = cur - > nextSibling ( ) ) {
TQCheckListItem * cli = dynamic_cast < TQCheckListItem * > ( cur ) ;
if ( cli & & cli - > isOn ( ) ) {
options + = ' , ' + cur - > text ( 0 ) ;
}
}
return options ;
}
// Some changes were made in the listview: add, edit oder delete entries.
// This means that the defaultOptions-dictionary, the selectedOptions-dictionary
// and the list of all options may be . So the documentClass-dictionary,
// the defaultOptions-dictionary and the selectedOptions-dictionary must be updated.
void QuickDocument : : updateClassOptions ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::updateClassOptions()============ " < < endl ;
KILE_DEBUG ( ) < < " \t class: " < < m_currentClass < < endl ;
TQString defaultoptions ;
TQStringList newlist ;
TQStringList oldlist = m_dictDocumentClasses [ m_currentClass ] ;
// read the first four static entries
newlist < < oldlist [ qd_Fontsizes ] ;
newlist < < oldlist [ qd_Papersizes ] ;
newlist < < TQString ( ) ; // dummy entry: will be changed
newlist < < getClassOptions ( ) ;
// read all options
for ( TQListViewItem * cur = m_lvClassOptions - > firstChild ( ) ; cur ; cur = cur - > nextSibling ( ) ) {
TQCheckListItem * cli = dynamic_cast < TQCheckListItem * > ( cur ) ;
if ( cli ) {
TQString description = cur - > text ( 1 ) ;
if ( description . right ( 10 ) = = " [default] " ) {
description = stripDefault ( description ) ;
if ( ! defaultoptions . isEmpty ( ) )
defaultoptions + = ' , ' ;
defaultoptions + = cur - > text ( 0 ) ;
}
newlist + = cur - > text ( 0 ) + " => " + description ;
}
}
// update list entry with defaultoptions
newlist [ qd_DefaultOptions ] = defaultoptions ;
// insert this changed list into the documentClass-dictionary
m_dictDocumentClasses [ m_currentClass ] = newlist ;
// update other dictionaries
setDefaultClassOptions ( newlist [ qd_DefaultOptions ] ) ;
setSelectedClassOptions ( newlist [ qd_SelectedOptions ] ) ;
}
// Insert all entries from a comma separated list into a combobox.
// If this entry matches a given text, this entry will be activated.
void QuickDocument : : fillCombobox ( KComboBox * combo , const TQString & cslist , const TQString & seltext )
{
bool documentclasscombo = ( combo = = m_cbDocumentClass ) ;
TQListBox * listbox = combo - > listBox ( ) ;
TQString sep = ( m_currentClass = = " beamer " & & combo = = m_cbPaperSize ) ? " ; " : " , " ;
TQStringList list = TQStringList : : split ( sep , cslist ) ;
if ( ! documentclasscombo )
list . sort ( ) ;
combo - > clear ( ) ;
for ( uint i = 0 ; i < list . count ( ) ; + + i ) {
if ( ! documentclasscombo & & isDefaultClassOption ( list [ i ] ) )
combo - > insertItem ( TQString ( list [ i ] ) + " [default] " ) ;
else if ( list [ i ] ! = " - " )
combo - > insertItem ( list [ i ] ) ;
else
{
ListBoxSeparator * separator = new ListBoxSeparator ( listbox - > item ( 0 ) - > height ( listbox ) ) ;
listbox - > insertItem ( separator ) ;
// doesn't work in constructor, so set it again here
separator - > setSelectable ( false ) ;
}
// should this entry be selected?
if ( ! seltext . isEmpty ( ) & & list [ i ] = = seltext )
combo - > setCurrentItem ( i ) ;
}
}
// Add some entries from a comma separated list to a sorted combobox.
// The new entries must match a regular expression or will be denied.
bool QuickDocument : : addComboboxEntries ( KComboBox * combo , const TQString & title , const TQString & entry )
{
// read current comboxbox entries
TQStringList combolist ;
for ( int i = 0 ; i < combo - > count ( ) ; + + i )
combolist + = combo - > text ( i ) ;
// add new entries (one or a comma separated list)
TQStringList list = TQStringList : : split ( " , " , entry ) ;
for ( uint i = 0 ; i < list . count ( ) ; + + i ) {
TQString s = list [ i ] . stripWhiteSpace ( ) ;
// entries must match a regular expression
if ( combolist . tqfindIndex ( s ) ! = - 1 )
KMessageBox : : error ( this , i18n ( " %1 '%2' already exists. " ) . tqarg ( title ) . tqarg ( s ) ) ;
else {
combolist + = s ;
KILE_DEBUG ( ) < < " \t insert new " < < title < < " : " < < s < < endl ;
}
}
// insert list, if there are more entries than before
if ( combolist . count ( ) > ( uint ) combo - > count ( ) ) {
fillCombobox ( combo , combolist . join ( " , " ) , list [ 0 ] ) ;
return true ;
} else {
return false ;
}
}
TQString QuickDocument : : getComboxboxList ( KComboBox * combo )
{
TQStringList list ;
for ( int i = 0 ; i < combo - > count ( ) ; + + i ) {
list + = combo - > text ( i ) ;
}
return ( list . count ( ) > 0 ) ? list . join ( " , " ) : TQString ( ) ;
}
// strip an optional default-tag from the string
TQString QuickDocument : : stripDefault ( const TQString & s )
{
return ( s . right ( 10 ) = = " [default] " ) ? s . left ( s . length ( ) - 10 ) : s ;
}
////////////////////////////// packages tab //////////////////////////////
void QuickDocument : : readPackagesConfig ( )
{
KILE_DEBUG ( ) < < " \t read config: packages " < < endl ;
if ( ! readPackagesListview ( ) )
initPackages ( ) ;
}
// init default values for packages tab
void QuickDocument : : initPackages ( )
{
KILE_DEBUG ( ) < < " read config: init standard packages " < < endl ;
TQCheckListItem * cli ;
TQCheckListItem * clichild ;
m_lvPackages - > clear ( ) ;
cli = insertListview ( m_lvPackages , " amsmath " , i18n ( " Special math environments and commands (AMS) " ) ) ;
cli = insertListview ( m_lvPackages , " amsfonts " , i18n ( " Collection of fonts and symbols for math mode (AMS) " ) ) ;
cli = insertListview ( m_lvPackages , " amssymb " , i18n ( " Defines symbol names for all math symbols in MSAM and MSBM (AMS) " ) ) ;
cli = insertListview ( m_lvPackages , " amsthm " , i18n ( " Improved theorem setup (AMS) " ) ) ;
cli = insertListview ( m_lvPackages , " caption " , i18n ( " Extends caption capabilities for figures and tables " ) ) ;
cli = insertListview ( m_lvPackages , " hyperref " , i18n ( " Hypertext marks in LaTeX " ) ) ;
cli - > setOpen ( true ) ;
clichild = insertListview ( cli , " dvips " , i18n ( " Use dvips as hyperref driver " ) ) ;
clichild - > setOn ( true ) ;
clichild = insertListview ( cli , " pdftex " , i18n ( " Use pdftex as hyperref driver " ) ) ;
clichild = insertEditableListview ( cli , " bookmarks " , i18n ( " Make bookmarks " ) , " true " , " true " ) ;
clichild = insertEditableListview ( cli , " bookmarksnumbered " , i18n ( " Put section numbers in bookmarks " ) , " false " , " false " ) ;
clichild = insertEditableListview ( cli , " bookmarksopen " , i18n ( " Open up bookmark tree " ) , TQString ( ) , TQString ( ) ) ;
clichild = insertEditableListview ( cli , " pdfauthor " , i18n ( " Text for PDF Author field " ) , TQString ( ) , TQString ( ) ) ;
clichild = insertEditableListview ( cli , " pdfcreator " , i18n ( " Text for PDF Creator field " ) , i18n ( " LaTeX with hyperref package " ) , i18n ( " LaTeX with hyperref package " ) ) ;
clichild = insertEditableListview ( cli , " pdffitwindow " , i18n ( " Resize document window to fit document size " ) , " false " , " false " ) ;
clichild = insertEditableListview ( cli , " pdfkeywords " , i18n ( " Text for PDF Keywords field " ) , TQString ( ) , TQString ( ) ) ;
clichild = insertEditableListview ( cli , " pdfproducer " , i18n ( " Text for PDF Producer field " ) , TQString ( ) , TQString ( ) ) ;
clichild = insertEditableListview ( cli , " pdfstartview " , i18n ( " Starting view of PDF document " ) , " /Fit " , " /Fit " ) ;
clichild = insertEditableListview ( cli , " pdfsubject " , i18n ( " Text for PDF Subject field " ) , TQString ( ) , TQString ( ) ) ;
clichild = insertEditableListview ( cli , " pdftitle " , i18n ( " Text for PDF Title field " ) , TQString ( ) , TQString ( ) ) ;
cli = insertListview ( m_lvPackages , " mathpazo " , i18n ( " Use Palatino font as roman font (both text and math mode) " ) ) ;
cli = insertListview ( m_lvPackages , " mathptmx " , i18n ( " Use Times font as roman font (both text and math mode) " ) ) ;
cli = insertListview ( m_lvPackages , " makeidx " , i18n ( " Enable index generation " ) ) ;
cli = insertListview ( m_lvPackages , " multicol " , i18n ( " Enables multicolumn environments " ) ) ;
cli = insertListview ( m_lvPackages , " pst-all " , i18n ( " Load all pstricks packages " ) ) ;
cli = insertListview ( m_lvPackages , " rotating " , i18n ( " Rotates text " ) ) ;
cli = insertListview ( m_lvPackages , " subfigure " , i18n ( " Enables subfigures inside figures " ) ) ;
cli = insertListview ( m_lvPackages , " upgreek " , i18n ( " Typesetting capital Greek letters " ) ) ;
cli = insertListview ( m_lvPackages , " xcolor " , i18n ( " Extending LaTeX's color facilities " ) ) ;
cli = insertListview ( m_lvPackages , " babel " , i18n ( " Adds language specific support " ) ) ;
cli - > setOn ( true ) ;
cli - > setOpen ( true ) ;
clichild = new TQCheckListItem ( cli , " acadian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " afrikaans " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " american " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " australian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " austrian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " bahasa " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " basque " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " brazil " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " brazilian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " breton " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " british " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " bulgarian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " canadian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " canadien " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " catalan " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " croatian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " czech " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " danish " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " dutch " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " english " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " esperanto " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " estonian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " finnish " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " francais " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " frenchb " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " french " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " galician " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " german " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " germanb " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " greek " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " polutonikogreek " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " hebrew " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " hungarian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " icelandic " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " interlingua " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " irish " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " italian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " latin " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " lowersorbian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " magyar " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " naustrian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " newzealand " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " ngerman " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " norsk " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " samin " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " nynorsk " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " polish " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " portuges " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " portuguese " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " romanian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " russian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " scottish " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " serbian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " slovak " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " slovene " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " spanish " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " swedish " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " turkish " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " ukrainian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " uppersorbian " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " welsh " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " UKenglish " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " USenglish " , TQCheckListItem : : CheckBox ) ;
cli = insertListview ( m_lvPackages , " fontenc " , i18n ( " Use a font encoding scheme " ) ) ;
cli - > setOn ( true ) ;
cli - > setOpen ( true ) ;
clichild = new TQCheckListItem ( cli , " HE8 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " IL2 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " LCH " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " LCY " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " LGR " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " LHE " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " LIT " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " LO1 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " LY1 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " MTT " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " OML " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " OMS " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " OT1 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " OT2 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " OT4 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " PD1 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " PU " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " QX " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " T1 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " T2A " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " T2B " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " T2C " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " T5 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " TS1 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " UT1 " , TQCheckListItem : : CheckBox ) ;
clichild = new TQCheckListItem ( cli , " X2 " , TQCheckListItem : : CheckBox ) ;
cli = insertListview ( m_lvPackages , " graphicx " , i18n ( " Support for including graphics " ) ) ;
cli - > setOn ( true ) ;
cli - > setOpen ( true ) ;
clichild = insertListview ( cli , " dvips " , i18n ( " Specialize on graphic inclusion for dvips " ) ) ;
clichild = insertListview ( cli , " pdftex " , i18n ( " Specialize on graphic inclusion for pdftex " ) ) ;
clichild = insertListview ( cli , " draft " , i18n ( " Show only frames of graphics " ) ) ;
}
// Try to read values from the config file:
// - main entry: selected,open,empty,empty,description
// - child entry: selected,editable,defaultvalue,value,description
bool QuickDocument : : readPackagesListview ( )
{
KILE_DEBUG ( ) < < " \t read config: packages from config file " < < endl ;
TQStringList elements = KileConfig : : packagesList ( ) ;
// clear packages dictionaries and listview
m_dictPackagesEditable . clear ( ) ;
m_dictPackagesDefaultvalues . clear ( ) ;
m_lvPackages - > clear ( ) ;
if ( elements . empty ( ) )
return false ;
// regular expression to split the string from the config file
TQRegExp reg ( " ([^,]*) , ( [ ^ , ] * ) , ( [ ^ , ] * ) , ( [ ^ , ] * ) , ( . * ) " ) ;
m_config - > setGroup ( " QuickDocument/Packages " ) ;
for ( TQStringList : : Iterator it = elements . begin ( ) ; it ! = elements . end ( ) ; + + it ) {
TQCheckListItem * cli ;
// look, if this is a main or a child entry
KILE_DEBUG ( ) < < " \t read config entry: " < < * it < < endl ;
int pos = ( * it ) . tqfind ( ' ! ' ) ;
if ( pos = = - 1 ) { // main entry
cli = new TQCheckListItem ( m_lvPackages , * it , TQCheckListItem : : CheckBox ) ;
if ( reg . exactMatch ( m_config - > readEntry ( * it ) ) ) {
if ( reg . cap ( 1 ) = = " 1 " ) // selected state (entry 1)
cli - > setOn ( true ) ;
if ( reg . cap ( 2 ) = = " 1 " ) // open state (entry 2)
cli - > setOpen ( true ) ;
cli - > setText ( 2 , reg . cap ( 5 ) ) ; // description (entry 5)
} else {
KILE_DEBUG ( ) < < " \t wrong config entry for package " < < cli - > text ( 0 ) < < endl ;
}
} else { // child entry
cli = dynamic_cast < TQCheckListItem * > ( m_lvPackages - > tqfindItem ( ( * it ) . left ( pos ) , 0 ) ) ;
if ( cli ) {
TQCheckListItem * clichild ;
if ( reg . exactMatch ( m_config - > readEntry ( * it ) ) ) {
if ( reg . cap ( 2 ) = = " 1 " ) { // editable state
clichild = insertEditableListview ( cli , ( * it ) . mid ( pos + 1 ) , reg . cap ( 5 ) , reg . cap ( 4 ) , reg . cap ( 3 ) ) ;
} else {
clichild = new TQCheckListItem ( cli , ( * it ) . mid ( pos + 1 ) , TQCheckListItem : : CheckBox ) ;
clichild - > setText ( 2 , reg . cap ( 5 ) ) ; // description
}
if ( reg . cap ( 1 ) = = " 1 " ) // selected state
clichild - > setOn ( true ) ;
} else {
KILE_DEBUG ( ) < < " \t wrong config entry for package option " < < cli - > text ( 0 ) < < endl ;
}
} else {
KILE_DEBUG ( ) < < " \t listview entry for package " < < ( * it ) . left ( pos ) < < " not found " < < endl ;
}
}
}
return true ;
}
void QuickDocument : : writePackagesConfig ( )
{
KILE_DEBUG ( ) < < " \t write config: packages " < < endl ;
TQStringList packagesList ;
m_config - > setGroup ( " QuickDocument/Packages " ) ;
for ( TQListViewItem * cur = m_lvPackages - > firstChild ( ) ; cur ; cur = cur - > nextSibling ( ) ) {
KILE_DEBUG ( ) < < " \t write config: " < < cur - > text ( 0 ) < < endl ;
// add to packages list
packagesList + = cur - > text ( 0 ) ;
// determine config entry
TQString packageentry ;
// look for selected entries
TQCheckListItem * cli = dynamic_cast < TQCheckListItem * > ( cur ) ;
if ( cli & & cli - > isOn ( ) )
packageentry = " 1, " ;
else
packageentry = " 0, " ;
// look if this listitem is opened
if ( cli & & cli - > isOpen ( ) )
packageentry + = " 1, " ;
else
packageentry + = " 0, " ;
// two dummy entries and finally the description
packageentry + = " ,, " + cur - > text ( 2 ) ;
// write listview entry
m_config - > writeEntry ( cur - > text ( 0 ) , packageentry ) ;
// look for tqchildren
for ( TQListViewItem * curchild = cur - > firstChild ( ) ; curchild ; curchild = curchild - > nextSibling ( ) ) {
// add child to packages list
TQString option = cur - > text ( 0 ) + ' ! ' + curchild - > text ( 0 ) ;
packagesList + = option ;
KILE_DEBUG ( ) < < " \t write config: " < < option < < endl ;
// determine config entry
TQString optionentry ;
// look for selected options
TQCheckListItem * clichild = dynamic_cast < TQCheckListItem * > ( curchild ) ;
if ( clichild & & clichild - > isOn ( ) )
optionentry = " 1, " ;
else
optionentry = " 0, " ;
// look, if this child is editable
if ( clichild & & m_dictPackagesEditable . tqcontains ( option ) ) {
optionentry + = " 1, " ;
if ( m_dictPackagesDefaultvalues . tqcontains ( option ) )
optionentry + = m_dictPackagesDefaultvalues [ option ] + ' , ' ;
else
optionentry + = ' , ' ;
} else
optionentry + = " 0,, " ;
// add a value and a description
optionentry + = getPackagesValue ( curchild - > text ( 1 ) )
+ ' , ' + stripPackageDefault ( option , curchild - > text ( 2 ) ) ;
// write listview entry
m_config - > writeEntry ( option , optionentry ) ;
}
}
// write the list of all packages
KileConfig : : setPackagesList ( packagesList ) ;
}
// insert package
TQCheckListItem * QuickDocument : : insertListview ( TQListView * listview ,
const TQString & entry ,
const TQString & description )
{
TQCheckListItem * item = new TQCheckListItem ( listview , entry , TQCheckListItem : : CheckBox ) ;
if ( ! description . isEmpty ( ) )
item - > setText ( 2 , description ) ;
return item ;
}
// insert package option (not editable)
TQCheckListItem * QuickDocument : : insertListview ( TQCheckListItem * tqparent ,
const TQString & entry ,
const TQString & description )
{
TQCheckListItem * item = new TQCheckListItem ( tqparent , entry , TQCheckListItem : : CheckBox ) ;
if ( ! description . isEmpty ( ) )
item - > setText ( 2 , description ) ;
return item ;
}
// insert package option (editable)
TQCheckListItem * QuickDocument : : insertEditableListview ( TQCheckListItem * tqparent ,
const TQString & entry , const TQString & description ,
const TQString value , const TQString defaultvalue )
{
TQCheckListItem * item = new EditableCheckListItem ( tqparent , entry ) ;
TQString option = tqparent - > text ( 0 ) + ' ! ' + entry ;
m_dictPackagesEditable [ option ] = true ;
if ( ! defaultvalue . isEmpty ( ) )
m_dictPackagesDefaultvalues [ option ] = defaultvalue ;
setPackagesValue ( item , option , value ) ;
if ( ! description . isEmpty ( ) )
item - > setText ( 2 , addPackageDefault ( option , description ) ) ;
return item ;
}
void QuickDocument : : setPackagesValue ( TQListViewItem * item , const TQString & option , const TQString & val )
{
TQString defaultvalue = ( m_dictPackagesDefaultvalues . tqcontains ( option ) )
? m_dictPackagesDefaultvalues [ option ] : TQString ( ) ;
TQString value = ( ! val . isEmpty ( ) ) ? val : TQString ( ) ;
if ( value = = defaultvalue )
item - > setText ( 1 , i18n ( " <default> " ) ) ;
else if ( value . isEmpty ( ) )
item - > setText ( 1 , i18n ( " <empty> " ) ) ;
else
item - > setText ( 1 , value ) ;
}
TQString QuickDocument : : getPackagesValue ( const TQString & value )
{
return ( value = = i18n ( " <default> " ) | | value = = i18n ( " <empty> " ) ) ? TQString ( ) : value ;
}
bool QuickDocument : : isListviewEntry ( TQListView * listview , const TQString & entry )
{
for ( TQListViewItem * cur = listview - > firstChild ( ) ; cur ; cur = cur - > nextSibling ( ) ) {
if ( cur - > text ( 0 ) = = entry )
return true ;
}
return false ;
}
bool QuickDocument : : isListviewChild ( TQListView * listview , const TQString & entry , const TQString & option )
{
for ( TQListViewItem * cur = listview - > firstChild ( ) ; cur ; cur = cur - > nextSibling ( ) ) {
// look for the main entry
if ( cur - > text ( 0 ) = = entry ) {
// look for tqchildren
for ( TQListViewItem * curchild = cur - > firstChild ( ) ; curchild ; curchild = curchild - > nextSibling ( ) ) {
if ( option = = curchild - > text ( 0 ) )
return true ;
}
return false ;
}
}
return false ;
}
TQString QuickDocument : : addPackageDefault ( const TQString & option , const TQString & description )
{
return ( m_dictPackagesDefaultvalues . tqcontains ( option ) )
? description + " [ " + m_dictPackagesDefaultvalues [ option ] + ' ] '
: description + " [ ] " ;
}
TQString QuickDocument : : stripPackageDefault ( const TQString & option , const TQString & description )
{
TQRegExp reg ( " (.*) \ \ [ ( [ ^ \ \ [ ] * ) \ \ ] " ) ;
if ( description . right ( 4 ) = = " [ ] " )
return description . left ( description . length ( ) - 4 ) ;
if ( ! reg . exactMatch ( description ) )
return description ;
return ( reg . cap ( 2 ) . isEmpty ( ) | |
( m_dictPackagesDefaultvalues . tqcontains ( option ) & & m_dictPackagesDefaultvalues [ option ] = = reg . cap ( 2 ) )
) ? reg . cap ( 1 ) : description ;
}
////////////////////////////// hyperref tab //////////////////////////////
void QuickDocument : : initHyperref ( )
{
KILE_DEBUG ( ) < < " \t read config: init hyperref " < < endl ;
TQString driver = " dvipdf,dvipdfm,dvips,dvipsone, "
" dviwindo,hypertex,latex2html,pdftex, "
" ps2pdf,tex4ht,textures,vtex " ;
TQStringList list = TQStringList : : split ( " , " , driver ) ;
m_dictHyperrefDriver . clear ( ) ;
for ( uint i = 0 ; i < list . count ( ) ; + + i )
m_dictHyperrefDriver [ list [ i ] ] = true ;
}
bool QuickDocument : : isHyperrefDriver ( const TQString & name )
{
return m_dictHyperrefDriver . tqcontains ( name ) ;
}
////////////////////////////// check for existing exntries //////////////////////////////
bool QuickDocument : : isDocumentClass ( const TQString & name )
{
for ( int i = 0 ; i < m_cbDocumentClass - > count ( ) ; + + i ) {
if ( m_cbDocumentClass - > text ( i ) = = name )
return true ;
}
return false ;
}
bool QuickDocument : : isDocumentClassOption ( const TQString & option )
{
return isListviewEntry ( m_lvClassOptions , option ) ;
}
bool QuickDocument : : isPackage ( const TQString & package )
{
return isListviewEntry ( m_lvPackages , package ) ;
}
bool QuickDocument : : isPackageOption ( const TQString & package , const TQString & option )
{
return isListviewChild ( m_lvPackages , package , option ) ;
}
////////////////////////////// print document template //////////////////////////////
void QuickDocument : : printTemplate ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::printTemplate()============ " < < endl ;
// get current document class
TQString documentclass = m_cbDocumentClass - > currentText ( ) ;
KILE_DEBUG ( ) < < " \t document class: " < < documentclass < < endl ;
// build template
m_td . tagBegin = " \\ documentclass " ;
// build options
TQString options ;
if ( documentclass ! = " beamer " ) {
if ( ! m_cbPaperSize - > currentText ( ) . isEmpty ( ) )
options + = stripDefault ( m_cbPaperSize - > currentText ( ) ) + ' , ' ;
}
if ( ! m_cbTypefaceSize - > currentText ( ) . isEmpty ( ) )
options + = stripDefault ( m_cbTypefaceSize - > currentText ( ) ) + ' , ' ;
for ( TQListViewItem * cur = m_lvClassOptions - > firstChild ( ) ; cur ; cur = cur - > nextSibling ( ) ) {
TQCheckListItem * cli = dynamic_cast < TQCheckListItem * > ( cur ) ;
if ( cli & & cli - > isOn ( ) )
options + = cur - > text ( 0 ) + ' , ' ;
}
if ( ! options . isEmpty ( ) )
m_td . tagBegin + = ' [ ' + options . left ( options . length ( ) - 1 ) + ' ] ' ;
m_td . tagBegin + = ' { ' + documentclass + " } \n \n " ;
TQString enc = m_cbEncoding - > currentText ( ) ;
if ( ! enc . isEmpty ( ) )
{
if ( enc . tqfind ( " utf " ) ! = - 1 )
m_td . tagBegin + = " \\ usepackage{ucs} \n " ;
m_td . tagBegin + = " \\ usepackage[ " + enc + " ]{inputenc} \n " ;
}
if ( documentclass ! = " beamer " ) {
printPackages ( ) ;
printHyperref ( ) ;
} else {
printBeamerTheme ( ) ;
printPackages ( ) ;
}
if ( ! m_leAuthor - > text ( ) . isEmpty ( ) )
m_td . tagBegin + = " \\ author{ " + m_leAuthor - > text ( ) + " } \n " ;
if ( ! m_leTitle - > text ( ) . isEmpty ( ) )
m_td . tagBegin + = " \\ title{ " + m_leTitle - > text ( ) + " } \n " ;
if ( ! m_leDate - > text ( ) . isEmpty ( ) )
m_td . tagBegin + = " \\ date{ " + m_leDate - > text ( ) + " } \n " ;
m_td . tagBegin + = ' \n ' ;
m_td . tagBegin + = " \\ begin{document} \n %E%C " ;
m_td . tagEnd = " \n \\ end{document} \n " ;
}
void QuickDocument : : printPackages ( )
{
KILE_DEBUG ( ) < < " \t packages " < < endl ;
m_currentHyperref = false ;
m_hyperrefdriver = TQString ( ) ;
m_hyperrefsetup = TQString ( ) ;
for ( TQListViewItem * cur = m_lvPackages - > firstChild ( ) ; cur ; cur = cur - > nextSibling ( ) ) {
TQCheckListItem * cli = dynamic_cast < TQCheckListItem * > ( cur ) ;
if ( ! cli )
continue ;
if ( cur - > text ( 0 ) = = " hyperref " ) { // manage hyperref package
m_currentHyperref = cli - > isOn ( ) ;
for ( TQListViewItem * curchild = cur - > firstChild ( ) ; curchild ; curchild = curchild - > nextSibling ( ) ) {
TQCheckListItem * clichild = dynamic_cast < TQCheckListItem * > ( curchild ) ;
if ( clichild & & clichild - > isOn ( ) ) { // manage hyperref option
if ( isHyperrefDriver ( curchild - > text ( 0 ) ) ) { // either hyperref driver
if ( ! m_hyperrefdriver . isEmpty ( ) )
m_hyperrefdriver + = ' , ' ;
m_hyperrefdriver + = curchild - > text ( 0 ) ;
} else {
TQString value = curchild - > text ( 1 ) ; // or another option
if ( value ! = i18n ( " <default> " ) ) {
if ( ! m_hyperrefsetup . isEmpty ( ) )
m_hyperrefsetup + = ' , ' ;
m_hyperrefsetup + = " % \n " + curchild - > text ( 0 ) + ' = ' + getPackagesValue ( curchild - > text ( 1 ) ) ;
}
}
}
}
} else if ( cli - > isOn ( ) ) { // manage other package options
TQString packageOptions ;
for ( TQListViewItem * curchild = cur - > firstChild ( ) ; curchild ; curchild = curchild - > nextSibling ( ) ) {
TQCheckListItem * clichild = dynamic_cast < TQCheckListItem * > ( curchild ) ;
if ( clichild & & clichild - > isOn ( ) ) {
TQString optiontext ;
if ( m_dictPackagesEditable . tqcontains ( cur - > text ( 0 ) + ' ! ' + curchild - > text ( 0 ) ) ) {
TQString value = curchild - > text ( 1 ) ;
if ( value ! = i18n ( " <default> " ) )
optiontext = curchild - > text ( 0 ) + ' = ' + getPackagesValue ( curchild - > text ( 1 ) ) ;
} else
optiontext = curchild - > text ( 0 ) ;
if ( ! optiontext . isEmpty ( ) ) {
if ( ! packageOptions . isEmpty ( ) )
packageOptions + = ' , ' ;
packageOptions + = optiontext ;
}
}
}
m_td . tagBegin + = " \\ usepackage " ;
if ( ! packageOptions . isEmpty ( ) )
m_td . tagBegin + = ' [ ' + packageOptions + ' ] ' ;
m_td . tagBegin + = ' { ' + cur - > text ( 0 ) + " } \n " ;
}
}
m_td . tagBegin + = ' \n ' ;
}
void QuickDocument : : printHyperref ( )
{
if ( ! m_currentHyperref )
return ;
KILE_DEBUG ( ) < < " \t hyperref " < < endl ;
// output hyperref package
m_td . tagBegin + = " \\ usepackage " ;
if ( ! m_hyperrefdriver . isEmpty ( ) )
m_td . tagBegin + = ' [ ' + m_hyperrefdriver + ' ] ' ;
m_td . tagBegin + = " {hyperref} \n " ;
// output hyperref options
if ( ! m_hyperrefsetup . isEmpty ( ) ) {
m_td . tagBegin + = " \\ hypersetup{ " + m_hyperrefsetup + " % \n } \n " ;
}
m_td . tagBegin + = ' \n ' ;
}
void QuickDocument : : printBeamerTheme ( )
{
KILE_DEBUG ( ) < < " \t beamer theme " < < endl ;
TQString theme = m_cbPaperSize - > currentText ( ) ;
TQRegExp reg ( " ( \\ w+) \ \ s + \ \ ( ( . * ) \ \ ) $ " ) ;
if ( reg . search ( theme ) > = 0 ) {
TQStringList optionlist = TQStringList : : split ( " , " , reg . cap ( 2 ) ) ;
m_td . tagBegin + = " \\ usepackage[ " + optionlist . join ( " , " ) + " ]{beamertheme " + reg . cap ( 1 ) + " } \n \n " ;
} else {
m_td . tagBegin + = " \\ usepackage{beamertheme " + theme + " } \n \n " ;
}
}
////////////////////////////// Slots //////////////////////////////
void QuickDocument : : slotOk ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::slotOk()============ " < < endl ;
// get current class options
m_currentClass = m_cbDocumentClass - > currentText ( ) ;
KILE_DEBUG ( ) < < " \t current class: " < < m_currentClass < < endl ;
// save the checked options
m_dictDocumentClasses [ m_currentClass ] [ qd_SelectedOptions ] = getClassOptions ( ) ;
KILE_DEBUG ( ) < < " \t save options: " < < m_dictDocumentClasses [ m_currentClass ] [ qd_SelectedOptions ] < < endl ;
// build template
printTemplate ( ) ;
// update config file
writeConfig ( ) ;
accept ( ) ;
}
////////////////////////////// slots: document class //////////////////////////////
void QuickDocument : : slotDocumentClassAdd ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::slotDocumentClassAdd()============ " < < endl ;
TQStringList list ;
list < < i18n ( " Document Class " )
< < " label,edit,label,combobox,checkbox,checkbox "
< < i18n ( " Please enter the new document &class: " )
< < TQString ( ) // 3
< < i18n ( " &Set all options from this standard class (optional): " )
< < " ,article,book,letter,report,scrartcl,scrbook,scrreprt " // 5
< < i18n ( " Use standard &fontsizes " ) // 6
< < i18n ( " Use standard &papersizes " ) // 7
;
if ( inputDialog ( list , qd_CheckNotEmpty | qd_CheckDocumentClass ) ) {
TQString classname = list [ 3 ] ;
TQStringList classlist ;
if ( list [ 5 ] . isEmpty ( ) ) { // no base class
TQString useFontsizes = ( list [ 6 ] = = " true " )
? " 10pt,11pt,12pt " : " " ;
TQString usePapersizes = ( list [ 7 ] = = " true " )
? " a4paper,a5paper,b5paper,executivepaper,legalpaper,letterpaper " : " " ;
KILE_DEBUG ( ) < < " \t add document class: " < < classname
< < " fontsize= " < < list [ 6 ] < < " papersize= " < < list [ 7 ] < < endl ;
// set default entries for the documentClass-dictionary
classlist < < useFontsizes < < usePapersizes < < " " < < " " ;
} else { // based on a standard class
// first get the first four parameters
classlist = m_dictDocumentClasses [ list [ 5 ] ] ;
// then add all baseclass options
TQStringList optionlist ;
initStandardOptions ( list [ 5 ] , optionlist ) ;
for ( uint i = 0 ; i < optionlist . count ( ) ; + + i )
classlist . append ( optionlist [ i ] ) ;
}
// insert the stringlist for this new document class
m_dictDocumentClasses [ classname ] = classlist ;
// add the new document class into the userClasslist and the documentClass-combobox
m_userClasslist . append ( classname ) ;
fillDocumentClassCombobox ( ) ;
// activate the new document class
m_cbDocumentClass - > setCurrentText ( classname ) ;
slotDocumentClassChanged ( m_cbDocumentClass - > currentItem ( ) ) ;
}
}
void QuickDocument : : slotDocumentClassDelete ( )
{
// get the name of the current class
TQString documentclass = m_cbDocumentClass - > currentText ( ) ;
KILE_DEBUG ( ) < < " ==QuickDocument::slotDocumentClassDelete()============ " < < endl ;
if ( KMessageBox : : warningContinueCancel ( this , i18n ( " Do you want to remove \" %1 \" from the document class list? " ) . tqarg ( documentclass ) , i18n ( " Remove Document Class " ) ) = = KMessageBox : : Continue )
{
KILE_DEBUG ( ) < < " \t lazy delete class: " < < documentclass < < endl ;
// remove this document class from the documentClass-dictionary
m_dictDocumentClasses . remove ( documentclass ) ;
// mark this document class for deleting from config file (only with OK-Button)
if ( m_deleteDocumentClasses . tqfindIndex ( documentclass ) = = - 1 )
m_deleteDocumentClasses . append ( documentclass ) ;
// remove it from the list of userclasses
m_userClasslist . remove ( documentclass ) ;
// and finally remove it from the combobox
int i = m_cbDocumentClass - > currentItem ( ) ;
m_cbDocumentClass - > removeItem ( i ) ;
m_cbDocumentClass - > setCurrentItem ( 0 ) ;
// init a new document class
m_currentClass = m_cbDocumentClass - > currentText ( ) ;
KILE_DEBUG ( ) < < " \t change class: --> " < < m_currentClass < < endl ;
initDocumentClass ( ) ;
}
}
void QuickDocument : : slotDocumentClassChanged ( int index )
{
KILE_DEBUG ( ) < < " ==QuickDocument::slotDocumentClassChanged()============ " < < endl ;
if ( m_cbDocumentClass - > text ( index ) . isNull ( ) ) {
KILE_DEBUG ( ) < < " \t null " < < endl ;
return ;
}
// get old and new document class
TQString oldclass = m_currentClass ;
m_currentClass = m_cbDocumentClass - > text ( index ) ;
KILE_DEBUG ( ) < < " \t change class: " < < oldclass < < " --> " < < m_currentClass < < endl ;
// save the checked options
m_dictDocumentClasses [ oldclass ] [ qd_SelectedOptions ] = getClassOptions ( ) ;
KILE_DEBUG ( ) < < " \t save options: " < < m_dictDocumentClasses [ oldclass ] [ qd_SelectedOptions ] < < endl ;
// init the new document class
initDocumentClass ( ) ;
}
void QuickDocument : : slotTypefaceSizeAdd ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::slotTypefaceSizeAdd()============ " < < endl ;
TQStringList list ;
list < < i18n ( " Add Fontsize " )
< < " label,edit "
< < i18n ( " Please enter the &fontsizes (comma-separated list): " )
< < TQString ( ) // 3
;
if ( inputDialog ( list , qd_CheckNotEmpty | qd_CheckFontsize ) ) {
KILE_DEBUG ( ) < < " \t add fontsize: " < < list [ 3 ] < < endl ;
addComboboxEntries ( m_cbTypefaceSize , " fontsize " , list [ 3 ] ) ;
// save the new list of fontsizes
m_dictDocumentClasses [ m_currentClass ] [ qd_Fontsizes ] = getComboxboxList ( m_cbTypefaceSize ) ;
}
}
void QuickDocument : : slotTypefaceSizeDelete ( )
{
if ( KMessageBox : : warningContinueCancel ( this , i18n ( " Do you want to remove \" %1 \" from the fontsize list? " ) . tqarg ( m_cbPaperSize - > currentText ( ) ) , i18n ( " Remove Fontsize " ) ) = = KMessageBox : : Continue )
{
int i = m_cbPaperSize - > currentItem ( ) ;
m_cbPaperSize - > removeItem ( i ) ;
// save the new list of fontsizes
m_dictDocumentClasses [ m_currentClass ] [ qd_Fontsizes ] = getComboxboxList ( m_cbTypefaceSize ) ;
}
}
void QuickDocument : : slotPaperSizeAdd ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::slotPaperSizeAdd()============ " < < endl ;
TQStringList list ;
list < < i18n ( " Add Papersize " )
< < " label,edit "
< < i18n ( " Please enter the &papersizes (comma-separated list): " )
< < TQString ( ) // 3
;
if ( inputDialog ( list , qd_CheckNotEmpty | qd_CheckPapersize ) ) {
KILE_DEBUG ( ) < < " \t add papersize: " < < list [ 3 ] < < endl ;
addComboboxEntries ( m_cbPaperSize , " papersize " , list [ 3 ] ) ;
// save the new list of papersizes
m_dictDocumentClasses [ m_currentClass ] [ qd_Papersizes ] = getComboxboxList ( m_cbPaperSize ) ;
}
}
void QuickDocument : : slotPaperSizeDelete ( )
{
if ( KMessageBox : : warningContinueCancel ( this , i18n ( " Do you want to remove \" %1 \" from the papersize list? " ) . tqarg ( m_cbPaperSize - > currentText ( ) ) , i18n ( " Remove Papersize " ) ) = = KMessageBox : : Continue )
{
int i = m_cbPaperSize - > currentItem ( ) ;
m_cbPaperSize - > removeItem ( i ) ;
// save the new list of papersizes
m_dictDocumentClasses [ m_currentClass ] [ qd_Papersizes ] = getComboxboxList ( m_cbPaperSize ) ;
}
}
////////////////////////////// slots: document class button //////////////////////////////
void QuickDocument : : slotClassOptionAdd ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::slotClassOptionAdd()============ " < < endl ;
TQStringList list ;
list < < i18n ( " Add Option " )
< < " label,edit,label,edit,checkbox "
< < i18n ( " Name of &option: " )
< < TQString ( ) // 3
< < i18n ( " &Description: " )
< < TQString ( ) // 5
< < i18n ( " &Select this option " ) // 6
;
if ( inputDialog ( list , qd_CheckNotEmpty | qd_CheckClassOption ) ) {
// get results
TQString option = list [ 3 ] ;
TQString description = list [ 5 ] ;
bool check = ( list [ 6 ] = = " true " ) ;
// add class option
KILE_DEBUG ( ) < < " \t add option: " < < option < < " ( " < < description < < " ) checked= " < < list [ 6 ] < < endl ;
TQCheckListItem * cli = new TQCheckListItem ( m_lvClassOptions , option , TQCheckListItem : : CheckBox ) ;
cli - > setText ( 1 , description ) ;
if ( check )
cli - > setOn ( true ) ;
// update dictionary
updateClassOptions ( ) ;
}
}
void QuickDocument : : slotClassOptionEdit ( )
{
TQListViewItem * cur = m_lvClassOptions - > selectedItem ( ) ;
if ( ! cur )
return ;
KILE_DEBUG ( ) < < " ==QuickDocument::slotClassOptionEdit()============ " < < endl ;
TQStringList list ;
list < < i18n ( " Edit Option " )
< < " label,edit-r,label,edit "
< < i18n ( " Name of &option: " )
< < cur - > text ( 0 )
< < i18n ( " &Description: " )
< < stripDefault ( cur - > text ( 1 ) ) // 5
;
//if ( inputDialog(list,qd_CheckNotEmpty | qd_CheckClassOption) ) {
if ( inputDialog ( list ) ) {
// get results
//TQString option = list[3];
TQString description = list [ 5 ] ;
// set changed class option
KILE_DEBUG ( ) < < " \t edit option: " < < cur - > text ( 0 ) < < " ( " < < description < < " ) " < < endl ;
//cur->setText(0, option);
cur - > setText ( 1 , description ) ;
// update dictionary
updateClassOptions ( ) ;
}
}
void QuickDocument : : slotClassOptionDelete ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::slotClassOptionDelete()============ " < < endl ;
if ( m_lvClassOptions - > selectedItem ( ) & & ( KMessageBox : : warningContinueCancel ( this , i18n ( " Do you want to delete this class option? " ) , i18n ( " Delete " ) ) = = KMessageBox : : Continue ) ) {
TQListViewItem * cur = m_lvClassOptions - > selectedItem ( ) ;
KILE_DEBUG ( ) < < " \t delete option: " < < cur - > text ( 0 ) < < " ( " < < cur - > text ( 1 ) < < " ) " < < endl ;
m_lvClassOptions - > takeItem ( m_lvClassOptions - > selectedItem ( ) ) ;
// update dictionary
updateClassOptions ( ) ;
}
}
void QuickDocument : : slotOptionDoubleClicked ( TQListViewItem * listViewItem , const TQPoint & , int )
{
TQCheckListItem * cli = dynamic_cast < TQCheckListItem * > ( listViewItem ) ;
if ( cli ) {
if ( ! cli - > isOn ( ) ) {
cli - > setOn ( true ) ;
}
else
cli - > setOn ( false ) ;
}
}
////////////////////////////// slots: packages //////////////////////////////
void QuickDocument : : slotPackageAdd ( )
{
KILE_DEBUG ( ) < < " ==QuickDocument::slotPackageAdd()============ " < < endl ;
TQStringList list ;
list < < i18n ( " Add Package " )
< < " label,edit,label,edit,checkbox "
< < i18n ( " &Package: " )
< < TQString ( ) // 3
< < i18n ( " &Description: " )
< < TQString ( ) // 5
< < i18n ( " &Select this package " ) // 6
;
if ( inputDialog ( list , qd_CheckNotEmpty | qd_CheckPackage ) ) {
KILE_DEBUG ( ) < < " \t add package: " < < list [ 3 ] < < " ( " < < list [ 5 ] < < " ) checked= " < < list [ 6 ] < < endl ;
TQCheckListItem * cli = new TQCheckListItem ( m_lvPackages , list [ 3 ] , TQCheckListItem : : CheckBox ) ;
cli - > setText ( 2 , list [ 5 ] ) ;
if ( list [ 6 ] = = " true " )
cli - > setOn ( true ) ;
}
}
void QuickDocument : : slotPackageAddOption ( )
{
TQListViewItem * cur = m_lvPackages - > selectedItem ( ) ;
if ( ! cur )
return ;
KILE_DEBUG ( ) < < " ==QuickDocument::packageAddOption()============ " < < endl ;
TQStringList list ;
list < < i18n ( " Add Option " )
< < " label,edit,checkbox,label,edit,label,edit,label,edit,checkbox "
< < i18n ( " &Option: " ) + " ( " + i18n ( " package: " ) + ' ' + cur - > text ( 0 ) + ' ) '
< < TQString ( ) // 3
< < i18n ( " &Editable " ) // 4
< < i18n ( " De&fault value: " )
< < TQString ( ) // 6
< < i18n ( " &Value: " )
< < TQString ( ) // 8
< < i18n ( " &Description: " )
< < TQString ( ) // 10
< < i18n ( " &Select this option " ) // 11
;
if ( ! cur - > tqparent ( ) & & inputDialog ( list , qd_CheckNotEmpty | qd_CheckPackageOption ) ) {
KILE_DEBUG ( ) < < " \t add option: " < < list [ 3 ] < < " ( " < < list [ 10 ] < < " ) checked= " < < list [ 11 ] < < endl ;
TQCheckListItem * cli ;
if ( list [ 4 ] = = " true " ) {
cli = insertEditableListview ( ( TQCheckListItem * ) cur , list [ 3 ] , list [ 10 ] , list [ 8 ] , list [ 6 ] ) ;
} else {
cli = new TQCheckListItem ( cur , list [ 3 ] , TQCheckListItem : : CheckBox ) ;
cli - > setText ( 2 , list [ 10 ] ) ;
}
if ( list [ 11 ] = = " true " )
cli - > setOn ( true ) ;
cur - > setOpen ( true ) ;
}
}
void QuickDocument : : slotPackageEdit ( )
{
TQListViewItem * cur = m_lvPackages - > selectedItem ( ) ;
if ( ! cur )
return ;
KILE_DEBUG ( ) < < " ==QuickDocument::slotPackageEdit()============ " < < endl ;
bool editableOption ;
TQString caption , labelText , optionname ;
if ( cur - > tqparent ( ) ) {
// checkmode = qd_CheckPackageOption;
caption = i18n ( " Edit Option " ) ;
labelText = i18n ( " Op&tion: " ) + " ( " + i18n ( " package: " ) + ' ' + cur - > tqparent ( ) - > text ( 0 ) + ' ) ' ;
optionname = cur - > tqparent ( ) - > text ( 0 ) + ' ! ' + cur - > text ( 0 ) ;
editableOption = m_dictPackagesEditable . tqcontains ( optionname ) ;
} else {
// checkmode = qd_CheckPackage;
caption = i18n ( " Edit Package " ) ;
labelText = i18n ( " &Package: " ) ;
optionname = TQString ( ) ;
editableOption = false ;
}
// create one of three different dialogs; edit package, edit editable option, edit option
TQStringList list ;
list < < caption ;
if ( editableOption ) {
TQString defaultvalue = ( m_dictPackagesDefaultvalues . tqcontains ( optionname ) )
? m_dictPackagesDefaultvalues [ optionname ]
: TQString ( ) ;
TQString value = ( cur - > text ( 1 ) = = i18n ( " <default> " ) )
? defaultvalue : getPackagesValue ( cur - > text ( 1 ) ) ;
list < < " label,edit-r,label,edit-r,label,edit,label,edit "
< < labelText
< < cur - > text ( 0 ) // 3
< < i18n ( " De&fault value: " )
< < defaultvalue // 5
< < i18n ( " &Value: " )
< < value // 7
< < i18n ( " &Description: " )
< < stripPackageDefault ( optionname , cur - > text ( 2 ) ) // 9
;
} else {
list < < " label,edit-r,label,edit "
< < labelText
< < cur - > text ( 0 ) // 3
< < i18n ( " &Description: " )
< < cur - > text ( 2 ) // 5
;
}
if ( inputDialog ( list ) ) {
if ( editableOption ) {
KILE_DEBUG ( ) < < " \t edit package: "
< < list [ 3 ]
< < " ( " < < list [ 7 ] < < " ) "
< < " ( " < < list [ 9 ] < < " ) "
< < endl ;
cur - > setText ( 0 , list [ 3 ] ) ;
setPackagesValue ( cur , optionname , list [ 7 ] ) ;
cur - > setText ( 2 , addPackageDefault ( optionname , list [ 9 ] ) ) ;
} else {
KILE_DEBUG ( ) < < " \t edit package: " < < list [ 3 ] < < " ( " < < list [ 5 ] < < " ) " < < endl ;
cur - > setText ( 0 , list [ 3 ] ) ;
cur - > setText ( 2 , list [ 5 ] ) ;
}
}
}
void QuickDocument : : slotPackageDelete ( )
{
TQListViewItem * cur = m_lvPackages - > selectedItem ( ) ;
if ( ! cur )
return ;
bool packageoption ;
TQString message , optionname ;
if ( cur - > tqparent ( ) ) {
packageoption = true ;
message = i18n ( " Do you want do delete this package option? " ) ;
optionname = cur - > tqparent ( ) - > text ( 0 ) + ' ! ' + cur - > text ( 0 ) ;
} else {
packageoption = false ;
message = i18n ( " Do you want to delete this package? " ) ;
optionname = cur - > text ( 0 ) ;
}
if ( KMessageBox : : warningContinueCancel ( this , message , i18n ( " Delete " ) ) = = KMessageBox : : Continue ) {
TQListViewItem * childcur = cur - > firstChild ( ) ;
while ( childcur ) {
TQListViewItem * nextchildcur = childcur - > nextSibling ( ) ;
delete childcur ;
childcur = nextchildcur ;
}
delete cur ;
// also delete entries for editable package option
if ( packageoption & & m_dictPackagesEditable . tqcontains ( optionname ) ) {
m_dictPackagesEditable . remove ( optionname ) ;
if ( m_dictPackagesDefaultvalues . tqcontains ( optionname ) )
m_dictPackagesDefaultvalues . remove ( optionname ) ;
}
}
}
void QuickDocument : : slotPackageReset ( )
{
if ( KMessageBox : : warningContinueCancel ( this , i18n ( " Do you want to reset this package list? " ) , i18n ( " Reset Package List " ) ) = = KMessageBox : : Continue )
{
KILE_DEBUG ( ) < < " \t reset packages " < < endl ;
initPackages ( ) ;
slotEnableButtons ( ) ;
}
}
void QuickDocument : : slotCheckParent ( TQListViewItem * listViewItem )
{
TQCheckListItem * cli = dynamic_cast < TQCheckListItem * > ( listViewItem ) ;
if ( cli & & listViewItem - > tqparent ( ) & & cli - > isOn ( ) ) {
TQCheckListItem * clitqparent = dynamic_cast < TQCheckListItem * > ( listViewItem - > tqparent ( ) ) ;
if ( clitqparent )
clitqparent - > setOn ( true ) ;
}
}
void QuickDocument : : slotPackageDoubleClicked ( TQListViewItem * listViewItem , const TQPoint & , int )
{
if ( listViewItem & & listViewItem - > tqparent ( ) ) {
TQCheckListItem * parentitem = dynamic_cast < TQCheckListItem * > ( listViewItem - > tqparent ( ) ) ;
TQString option = parentitem - > text ( 0 ) + ' ! ' + listViewItem - > text ( 0 ) ;
if ( m_dictPackagesEditable . tqcontains ( option ) )
slotPackageEdit ( ) ;
}
}
////////////////////////////// button states //////////////////////////////
void QuickDocument : : slotEnableButtons ( )
{
bool enable ;
enable = ( ! isStandardClass ( m_currentClass ) ) ;
// add/delete button
m_btnDocumentClassDelete - > setEnabled ( enable ) ;
m_btnTypefaceSizeAdd - > setEnabled ( enable ) ;
m_btnTypefaceSizeDelete - > setEnabled ( enable & & m_cbTypefaceSize - > count ( ) > 0 ) ;
m_btnPaperSizeAdd - > setEnabled ( enable ) ;
m_btnPaperSizeDelete - > setEnabled ( enable & & m_cbPaperSize - > count ( ) > 0 ) ;
// class options
m_btnClassOptionsAdd - > setEnabled ( enable ) ;
enable = ( enable & & ( m_lvClassOptions - > selectedItem ( ) ! = NULL ) ) ;
m_btnClassOptionsEdit - > setEnabled ( enable ) ;
m_btnClassOptionsDelete - > setEnabled ( enable ) ;
// packeges
TQListViewItem * cur = m_lvPackages - > selectedItem ( ) ;
if ( cur & & cur - > text ( 0 ) ! = " hyperref " ) {
m_btnPackagesEdit - > setEnabled ( true ) ;
m_btnPackagesDelete - > setEnabled ( true ) ;
if ( cur - > tqparent ( ) )
m_btnPackagesAddOption - > setEnabled ( false ) ;
else
m_btnPackagesAddOption - > setEnabled ( true ) ;
} else {
m_btnPackagesEdit - > setEnabled ( false ) ;
m_btnPackagesDelete - > setEnabled ( false ) ;
m_btnPackagesAddOption - > setEnabled ( false ) ;
}
}
////////////////////////////// input dialog //////////////////////////////
// A variable input dialog, whose widgets are determind by the entries of a stringlist.
// Entry 1 is always the label for the main lineedit, entry 2 the main lineedit. All
// other objects are optionale and their return values are not checked.
// 0 : caption (input: always)
// 1 : comma separated list of TQt widgets (label,checkbox,edit,edit-r)
// 2ff : strings for TQt widgets
bool QuickDocument : : inputDialog ( TQStringList & list , int check )
{
QuickDocumentInputDialog * dialog = new QuickDocumentInputDialog ( list , check , this , " inputDialog " ) ;
bool result = false ;
if ( dialog - > exec ( ) ) {
dialog - > getResults ( list ) ;
result = true ;
}
delete dialog ;
return result ;
}
QuickDocumentInputDialog : : QuickDocumentInputDialog ( const TQStringList & list , int check ,
QuickDocument * tqparent ,
const char * name )
: KDialogBase ( tqparent , name , true , list [ 0 ] , KDialogBase : : Ok | KDialogBase : : Cancel , KDialogBase : : Ok , true ) ,
m_parent ( tqparent ) ,
m_check ( check )
{
TQWidget * page = new TQWidget ( this ) ;
setMainWidget ( page ) ;
TQVBoxLayout * vl = new TQVBoxLayout ( page , 0 , spacingHint ( ) ) ;
int firstlinedit = - 1 ;
m_description = TQStringList : : split ( " , " , list [ 1 ] ) ;
for ( uint i = 0 ; i < m_description . count ( ) ; + + i ) {
// create the object
if ( m_description [ i ] = = " label " ) {
m_objectlist . append ( new TQLabel ( list [ i + 2 ] , page ) ) ;
} else if ( m_description [ i ] = = " checkbox " ) {
m_objectlist . append ( new TQCheckBox ( list [ i + 2 ] , page ) ) ;
} else if ( m_description [ i ] = = " combobox " ) {
KComboBox * combobox = new KComboBox ( page ) ;
combobox - > tqsetSizePolicy ( TQSizePolicy : : MinimumExpanding , TQSizePolicy : : Minimum ) ;
combobox - > setDuplicatesEnabled ( false ) ;
combobox - > insertStringList ( TQStringList : : split ( " , " , list [ i + 2 ] , true ) ) ;
if ( i > 0 & & m_description [ i - 1 ] = = " label " )
( ( TQLabel * ) m_objectlist [ i - 1 ] ) - > setBuddy ( combobox ) ;
m_objectlist . append ( combobox ) ;
} else {
m_objectlist . append ( new KLineEdit ( list [ i + 2 ] , page ) ) ;
if ( m_description [ i ] = = " edit-r " )
( ( KLineEdit * ) m_objectlist [ i ] ) - > setReadOnly ( true ) ;
else if ( firstlinedit = = - 1 )
firstlinedit = i ;
if ( i > 0 & & m_description [ i - 1 ] = = " label " )
( ( TQLabel * ) m_objectlist [ i - 1 ] ) - > setBuddy ( m_objectlist [ i ] ) ;
}
// insert the new object into the tqlayout
vl - > addWidget ( m_objectlist [ i ] ) ;
}
if ( firstlinedit ! = - 1 )
m_objectlist [ firstlinedit ] - > setFocus ( ) ;
vl - > addStretch ( 1 ) ;
page - > setMinimumWidth ( 350 ) ;
}
QuickDocumentInputDialog : : ~ QuickDocumentInputDialog ( )
{ }
void QuickDocumentInputDialog : : getResults ( TQStringList & list )
{
for ( uint i = 0 ; i < m_description . count ( ) ; + + i ) {
if ( m_description [ i ] = = " label " ) {
list [ i + 2 ] = ( ( TQLabel * ) m_objectlist [ i ] ) - > text ( ) ;
} else if ( m_description [ i ] = = " checkbox " ) {
list [ i + 2 ] = ( ( ( TQCheckBox * ) m_objectlist [ i ] ) - > isOn ( ) ) ? " true " : " false " ;
} else if ( m_description [ i ] = = " combobox " ) {
list [ i + 2 ] = ( ( KComboBox * ) m_objectlist [ i ] ) - > currentText ( ) ;
} else {
list [ i + 2 ] = ( ( KLineEdit * ) m_objectlist [ i ] ) - > text ( ) . simplifyWhiteSpace ( ) ;
}
}
}
// get the package name from string 'Option: (package: name)'
TQString QuickDocumentInputDialog : : getPackageName ( const TQString & text )
{
TQRegExp reg ( i18n ( " package: " ) + " ([^ \\ )]+) " ) ;
return ( reg . search ( text ) > = 0 ) ? reg . cap ( 1 ) : TQString ( ) ;
}
bool QuickDocumentInputDialog : : checkListEntries ( const TQString & title , const TQString & textlist ,
const TQString & pattern )
{
// split entries (one or a comma separated list)
TQStringList list = TQStringList : : split ( " , " , textlist ) ;
for ( uint i = 0 ; i < list . count ( ) ; + + i ) {
TQString s = list [ i ] . stripWhiteSpace ( ) ;
// entries must match a regular expression
TQRegExp reg ( pattern ) ;
if ( ! reg . exactMatch ( s ) ) {
KMessageBox : : error ( this , i18n ( " %1 '%2' is not allowed. " ) . tqarg ( title ) . tqarg ( s ) ) ;
return false ;
}
}
return true ;
}
// check the main result of the input dialog
void QuickDocumentInputDialog : : slotOk ( )
{
if ( m_check ) {
// get the label and main input string from the first label/linedit
TQString inputlabel = ( ( TQLabel * ) m_objectlist [ 0 ] ) - > text ( ) ;
TQString input = ( ( KLineEdit * ) m_objectlist [ 1 ] ) - > text ( ) . simplifyWhiteSpace ( ) ;
// should we check for an empty string
if ( ( m_check & qd_CheckNotEmpty ) & & input . isEmpty ( ) ) {
KMessageBox : : error ( this , i18n ( " An empty string is not allowed. " ) ) ;
return ;
}
// should we check for an existing document class
if ( m_check & qd_CheckDocumentClass ) {
if ( m_parent - > isDocumentClass ( input ) ) {
KMessageBox : : error ( this , i18n ( " This document class already exists. " ) ) ;
return ;
}
TQRegExp reg ( " \\ w+ " ) ;
if ( ! reg . exactMatch ( input ) ) {
KMessageBox : : error ( this , i18n ( " This is not an allowed name for a document class. " ) ) ;
return ;
}
}
// should we check for an existing document class option
if ( ( m_check & qd_CheckClassOption ) & & m_parent - > isDocumentClassOption ( input ) ) {
KMessageBox : : error ( this , i18n ( " This document class option already exists. " ) ) ;
return ;
}
// should we check for an existing package
if ( ( m_check & qd_CheckPackage ) & & m_parent - > isPackage ( input ) ) {
KMessageBox : : error ( this , i18n ( " This package already exists. " ) ) ;
return ;
}
// should we check for an existing package option
if ( m_check & qd_CheckPackageOption ) {
TQString package = getPackageName ( inputlabel ) ;
if ( package . isEmpty ( ) ) {
KMessageBox : : error ( this , i18n ( " Could not identify the package name. " ) ) ;
return ;
}
if ( m_parent - > isPackageOption ( package , input ) ) {
KMessageBox : : error ( this , i18n ( " This package option already exists. " ) ) ;
return ;
}
}
// should we check for a (list of) fontsizes
if ( ( m_check & qd_CheckFontsize ) & & ! checkListEntries ( " Fontsize " , input , " \\ d+pt " ) ) {
return ;
}
// should we check for a (list of) papersizes
if ( ( m_check & qd_CheckPapersize ) & & ! checkListEntries ( " Papersize " , input , " \\ w+ " ) ) {
return ;
}
}
accept ( ) ;
}
} // namespace
# include "quickdocumentdialog.moc"