//=============================================================================
//
// File : aliaseditor.cpp
// Creation date : Tue 29 Dec 2004 02:45:59 2002 GMT by Szymon Stefanek
//
// This file is part of the KVirc irc client distribution
// Copyright (C) 2004 Szymon Stefanek (pragma at kvirc dot net)
//
// This program is FREE software. You can redistribute it and/or
// modify it under the linkss of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your opinion) any later version.
//
// This program is distributed in the HOPE that it will be USEFUL,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
// See the GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, write to the Free Software Foundation,
// Inc. ,51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
//
//=============================================================================
# include "actioneditor.h"
# include "kvi_iconmanager.h"
# include "kvi_options.h"
# include "kvi_locale.h"
# include "kvi_imagedialog.h"
# include "kvi_config.h"
# include "kvi_filedialog.h"
# include "kvi_fileutils.h"
# include "kvi_scripteditor.h"
# include "kvi_debug.h"
# include "kvi_app.h"
# include "kvi_qstring.h"
# include "kvi_kvs_aliasmanager.h"
# include "kvi_filedialog.h"
# include "kvi_actionmanager.h"
# include "kvi_action.h"
# include "kvi_kvs_useraction.h"
# include "kvi_customtoolbarmanager.h"
# include <tqsplitter.h>
# include <tqlayout.h>
# include "kvi_tal_vbox.h"
# include <tqtooltip.h>
# include <tqpushbutton.h>
# include <tqdir.h>
# include <tqmessagebox.h>
# include <tqlineedit.h>
# include <tqcombobox.h>
# include <tqtoolbutton.h>
# include <tqcheckbox.h>
# include <tqtooltip.h>
# include <tqpainter.h>
# ifdef COMPILE_USE_QT4
# include <tq3header.h>
# else
# include <tqheader.h>
# endif
# include <tqtabwidget.h>
# include <kvi_tal_groupbox.h>
# include "kvi_valuelist.h"
# include <tqlabel.h>
extern KviActionEditorWindow * g_pActionEditorWindow ;
static TQString g_szLastEditedAction ;
# define LVI_ICON_SIZE 32
# define LVI_BORDER 4
# define LVI_SPACING 8
# define LVI_MINIMUM_TEXT_WIDTH 150
# define LVI_MINIMUM_CELL_WIDTH (LVI_MINIMUM_TEXT_WIDTH + LVI_BORDER + LVI_ICON_SIZE + LVI_SPACING + LVI_BORDER)
KviActionEditorListViewItem : : KviActionEditorListViewItem ( KviTalListView * v , KviActionData * a )
: KviTalListViewItem ( v , " " )
{
m_pActionData = a ;
m_pListView = v ;
m_pIcon = 0 ;
setupForActionData ( ) ;
}
KviActionEditorListViewItem : : ~ KviActionEditorListViewItem ( )
{
if ( m_pIcon ) delete m_pIcon ;
delete m_pActionData ;
}
void KviActionEditorListViewItem : : setupForActionData ( )
{
TQString t = " <b> " + m_pActionData - > m_szName + " </b> " ;
t + = " <br><font color= \" #808080 \" size= \" -1 \" > " + m_pActionData - > m_szVisibleName + " </font> " ;
m_szKey = m_pActionData - > m_szName . upper ( ) ;
m_pText = new TQSimpleRichText ( t , m_pListView - > font ( ) ) ;
if ( m_pIcon ) delete m_pIcon ;
TQPixmap * p = g_pIconManager - > getBigIcon ( m_pActionData - > m_szBigIcon ) ;
if ( p ) m_pIcon = new TQPixmap ( * p ) ;
else {
p = g_pIconManager - > getImage ( " kvi_bigicon_unknown.png " ) ;
if ( p ) m_pIcon = new TQPixmap ( * p ) ;
else m_pIcon = new TQPixmap ( LVI_ICON_SIZE , LVI_ICON_SIZE ) ;
}
setup ( ) ;
}
TQString KviActionEditorListViewItem : : key ( int , bool ) const
{
return m_szKey ;
}
void KviActionEditorListViewItem : : setup ( )
{
KviTalListViewItem : : setup ( ) ;
int iWidth = m_pListView - > visibleWidth ( ) ;
if ( iWidth < LVI_MINIMUM_CELL_WIDTH ) iWidth = LVI_MINIMUM_CELL_WIDTH ;
iWidth - = LVI_BORDER + LVI_ICON_SIZE + LVI_SPACING + LVI_BORDER ;
m_pText - > setWidth ( iWidth ) ;
int iHeight = m_pText - > height ( ) + ( 2 * LVI_BORDER ) ;
if ( iHeight < ( LVI_ICON_SIZE + ( 2 * LVI_BORDER ) ) ) iHeight = LVI_ICON_SIZE + ( 2 * LVI_BORDER ) ;
setHeight ( iHeight ) ;
}
void KviActionEditorListViewItem : : paintCell ( TQPainter * p , const TQColorGroup & cg , int column , int width , int align )
{
p - > fillRect ( TQRect ( 0 , 0 , width , height ( ) ) , isSelected ( ) ? cg . highlight ( ) : cg . base ( ) ) ;
p - > drawPixmap ( LVI_BORDER , LVI_BORDER , * m_pIcon ) ;
int afterIcon = LVI_BORDER + LVI_ICON_SIZE + LVI_SPACING ;
int www = m_pListView - > visibleWidth ( ) - ( afterIcon + LVI_BORDER ) ;
m_pText - > setWidth ( www ) ;
m_pText - > draw ( p , afterIcon , LVI_BORDER , TQRect ( afterIcon , LVI_BORDER , www , height ( ) - ( LVI_BORDER * 2 ) ) , cg ) ;
}
KviSingleActionEditor : : KviSingleActionEditor ( TQWidget * par , KviActionEditor * ed )
: TQWidget ( par )
{
m_pActionEditor = ed ;
m_pActionData = 0 ;
TQGridLayout * g = new TQGridLayout ( this , 3 , 2 , 0 , 4 ) ;
TQLabel * l = new TQLabel ( __tr2qs ( " Name: " ) , this ) ;
g - > addWidget ( l , 0 , 0 ) ;
m_pNameEdit = new TQLineEdit ( this ) ;
g - > addWidget ( m_pNameEdit , 0 , 1 ) ;
TQToolTip : : add ( m_pNameEdit , __tr2qs ( " Internal unique name for the action " ) ) ;
l = new TQLabel ( __tr2qs ( " Label: " ) , this ) ;
g - > addWidget ( l , 1 , 0 ) ;
m_pVisibleNameEdit = new TQLineEdit ( this ) ;
g - > addWidget ( m_pVisibleNameEdit , 1 , 1 ) ;
TQToolTip : : add ( m_pVisibleNameEdit , __tr2qs ( " Visible name for this action.<br>This string will be displayed to the user so it is a good idea to use $tr() here " ) ) ;
TQTabWidget * tw = new TQTabWidget ( this ) ;
g - > addMultiCellWidget ( tw , 2 , 2 , 0 , 1 ) ;
// code tab
TQWidget * tab = new TQWidget ( tw ) ;
TQGridLayout * gl = new TQGridLayout ( tab , 1 , 1 , 8 , 4 ) ;
m_pScriptEditor = KviScriptEditor : : createInstance ( tab ) ;
gl - > addWidget ( m_pScriptEditor , 0 , 0 ) ;
TQToolTip : : add ( m_pScriptEditor , __tr2qs ( " Action code " ) ) ;
tw - > addTab ( tab , __tr2qs ( " Code " ) ) ;
// properties tab
tab = new TQWidget ( tw ) ;
gl = new TQGridLayout ( tab , 7 , 4 , 8 , 4 ) ;
l = new TQLabel ( __tr2qs ( " Category: " ) , tab ) ;
gl - > addWidget ( l , 0 , 0 ) ;
m_pCategoryCombo = new TQComboBox ( false , tab ) ;
gl - > addMultiCellWidget ( m_pCategoryCombo , 0 , 0 , 1 , 3 ) ;
TQToolTip : : add ( m_pCategoryCombo , __tr2qs ( " Choose the category that best fits for this action " ) ) ;
l = new TQLabel ( __tr2qs ( " Description: " ) , tab ) ;
gl - > addWidget ( l , 1 , 0 ) ;
m_pDescriptionEdit = new TQLineEdit ( tab ) ;
gl - > addMultiCellWidget ( m_pDescriptionEdit , 1 , 1 , 1 , 3 ) ;
TQToolTip : : add ( m_pDescriptionEdit , __tr2qs ( " Visible short description for this action.<br>This string will be displayed to the user so it is a good idea to use $tr() here " ) ) ;
l = new TQLabel ( __tr2qs ( " Small Icon: " ) , tab ) ;
gl - > addWidget ( l , 2 , 0 ) ;
m_pSmallIconEdit = new TQLineEdit ( tab ) ;
gl - > addWidget ( m_pSmallIconEdit , 2 , 1 ) ;
m_pSmallIconButton = new TQToolButton ( tab ) ;
m_pSmallIconButton - > setMinimumSize ( TQSize ( 20 , 20 ) ) ;
connect ( m_pSmallIconButton , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( chooseSmallIcon ( ) ) ) ;
gl - > addWidget ( m_pSmallIconButton , 2 , 2 ) ;
TQString s = __tr2qs ( " The small icon associated to this action.<br> " \
" It will appear at least in the popup menus when this action is inserted.<br> " \
" It should be 16x16 pixels. " ) ;
TQToolTip : : add ( m_pSmallIconEdit , s ) ;
TQToolTip : : add ( m_pSmallIconButton , s ) ;
l = new TQLabel ( __tr2qs ( " Big Icon: " ) , tab ) ;
gl - > addWidget ( l , 3 , 0 ) ;
m_pBigIconEdit = new TQLineEdit ( tab ) ;
gl - > addWidget ( m_pBigIconEdit , 3 , 1 ) ;
m_pBigIconButton = new TQToolButton ( tab ) ;
m_pBigIconButton - > setMinimumSize ( TQSize ( 48 , 48 ) ) ;
m_pBigIconButton - > setUsesBigPixmap ( true ) ;
connect ( m_pBigIconButton , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( chooseBigIcon ( ) ) ) ;
gl - > addMultiCellWidget ( m_pBigIconButton , 3 , 4 , 2 , 3 ) ;
s = __tr2qs ( " The big icon associated to this action.<br> " \
" It will appear at least in the toolbar buttons when this action is inserted.<br> " \
" It should be 32x32 pixels. " ) ;
TQToolTip : : add ( m_pBigIconEdit , s ) ;
TQToolTip : : add ( m_pBigIconButton , s ) ;
l = new TQLabel ( __tr2qs ( " Key Sequence: " ) , tab ) ;
gl - > addMultiCellWidget ( l , 4 , 5 , 0 , 0 ) ;
m_pKeySequenceEdit = new TQLineEdit ( tab ) ;
gl - > addMultiCellWidget ( m_pKeySequenceEdit , 4 , 5 , 1 , 1 ) ;
TQToolTip : : add ( m_pKeySequenceEdit , __tr2qs ( " Optional keyboard sequence that will activate this action.<br> " \
" The sequence should be expressed as a string of up to four key codes separated by commas " \
" eventually combined with the modifiers \" Ctrl \" , \" Shift \" , \" Alt \" and \" Meta \" .<br> " \
" Examples of such sequences are \" Ctrl+X \" , \" Ctrl+Alt+Z \" , \" Ctrl+X,Ctrl+C \" ... " ) ) ;
l = new TQLabel ( tab ) ;
gl - > addMultiCellWidget ( l , 6 , 6 , 0 , 3 ) ;
gl - > setColStretch ( 1 , 1 ) ;
gl - > setRowStretch ( 6 , 1 ) ;
tw - > addTab ( tab , __tr2qs ( " Properties " ) ) ;
// flags tab
tab = new TQWidget ( tw ) ;
gl = new TQGridLayout ( tab , 12 , 4 , 8 , 4 ) ;
m_pNeedsContextCheck = new KviStyledCheckBox ( __tr2qs ( " Needs IRC Context " ) , tab ) ;
connect ( m_pNeedsContextCheck , TQT_SIGNAL ( toggled ( bool ) ) , this , TQT_SLOT ( needsContextCheckToggled ( bool ) ) ) ;
TQToolTip : : add ( m_pNeedsContextCheck , __tr2qs ( " Check this option if this action should be enabled only when " \
" the active window belongs to an irc context " ) ) ;
gl - > addMultiCellWidget ( m_pNeedsContextCheck , 0 , 0 , 0 , 3 ) ;
l = new TQLabel ( tab ) ;
l - > setMinimumWidth ( 40 ) ;
gl - > addWidget ( l , 1 , 0 ) ;
m_pNeedsConnectionCheck = new KviStyledCheckBox ( __tr2qs ( " Needs IRC Connection " ) , tab ) ;
connect ( m_pNeedsConnectionCheck , TQT_SIGNAL ( toggled ( bool ) ) , this , TQT_SLOT ( needsConnectionCheckToggled ( bool ) ) ) ;
TQToolTip : : add ( m_pNeedsConnectionCheck , __tr2qs ( " Check this option if this action should be enabled only when " \
" the active window has an active IRC connection " ) ) ;
gl - > addMultiCellWidget ( m_pNeedsConnectionCheck , 1 , 1 , 1 , 3 ) ;
l = new TQLabel ( tab ) ;
l - > setMinimumWidth ( 40 ) ;
gl - > addWidget ( l , 2 , 1 ) ;
m_pEnableAtLoginCheck = new KviStyledCheckBox ( __tr2qs ( " Enable at Login " ) , tab ) ;
TQToolTip : : add ( m_pEnableAtLoginCheck , __tr2qs ( " Check this option if this action should be enabled also during " \
" the login operations (so when the logical IRC connection hasn't been estabilished yet) " ) ) ;
gl - > addMultiCellWidget ( m_pEnableAtLoginCheck , 2 , 2 , 2 , 3 ) ;
m_pSpecificWindowsCheck = new KviStyledCheckBox ( __tr2qs ( " Enable Only in Specified Windows " ) , tab ) ;
connect ( m_pSpecificWindowsCheck , TQT_SIGNAL ( toggled ( bool ) ) , this , TQT_SLOT ( specificWindowsCheckToggled ( bool ) ) ) ;
TQToolTip : : add ( m_pSpecificWindowsCheck , __tr2qs ( " Check this option if this action should be enabled only when " \
" the active window is of a specified type " ) ) ;
gl - > addMultiCellWidget ( m_pSpecificWindowsCheck , 3 , 3 , 0 , 3 ) ;
m_pWindowConsoleCheck = new KviStyledCheckBox ( __tr2qs ( " Enable in Console Windows " ) , tab ) ;
TQToolTip : : add ( m_pWindowConsoleCheck , __tr2qs ( " Check this option if this action should be enabled only when " \
" the active window is a console " ) ) ;
connect ( m_pWindowConsoleCheck , TQT_SIGNAL ( toggled ( bool ) ) , this , TQT_SLOT ( channelQueryOrConsoleWindowCheckToggled ( bool ) ) ) ;
gl - > addMultiCellWidget ( m_pWindowConsoleCheck , 4 , 4 , 1 , 3 ) ;
m_pConsoleOnlyIfUsersSelectedCheck = new KviStyledCheckBox ( __tr2qs ( " Only If There Are Selected Users " ) , tab ) ;
TQToolTip : : add ( m_pConsoleOnlyIfUsersSelectedCheck , __tr2qs ( " This will enable the action only if there are " \
" selected users in the active window " ) ) ;
gl - > addMultiCellWidget ( m_pConsoleOnlyIfUsersSelectedCheck , 5 , 5 , 2 , 3 ) ;
m_pWindowChannelCheck = new KviStyledCheckBox ( __tr2qs ( " Enable in Channel Windows " ) , tab ) ;
TQToolTip : : add ( m_pWindowChannelCheck , __tr2qs ( " Check this option if this action should be enabled only when " \
" the active window is a channel " ) ) ;
connect ( m_pWindowChannelCheck , TQT_SIGNAL ( toggled ( bool ) ) , this , TQT_SLOT ( channelQueryOrConsoleWindowCheckToggled ( bool ) ) ) ;
gl - > addMultiCellWidget ( m_pWindowChannelCheck , 6 , 6 , 1 , 3 ) ;
m_pChannelOnlyIfUsersSelectedCheck = new KviStyledCheckBox ( __tr2qs ( " Only If There Are Selected Users " ) , tab ) ;
TQToolTip : : add ( m_pChannelOnlyIfUsersSelectedCheck , __tr2qs ( " This will enable the action only if there are " \
" selected users in the active window " ) ) ;
gl - > addMultiCellWidget ( m_pChannelOnlyIfUsersSelectedCheck , 7 , 7 , 2 , 3 ) ;
m_pWindowQueryCheck = new KviStyledCheckBox ( __tr2qs ( " Enable in Query Windows " ) , tab ) ;
TQToolTip : : add ( m_pWindowQueryCheck , __tr2qs ( " Check this option if this action should be enabled only when " \
" the active window is a query " ) ) ;
connect ( m_pWindowQueryCheck , TQT_SIGNAL ( toggled ( bool ) ) , this , TQT_SLOT ( channelQueryOrConsoleWindowCheckToggled ( bool ) ) ) ;
gl - > addMultiCellWidget ( m_pWindowQueryCheck , 8 , 8 , 1 , 3 ) ;
m_pQueryOnlyIfUsersSelectedCheck = new KviStyledCheckBox ( __tr2qs ( " Only If There Are Selected Users " ) , tab ) ;
TQToolTip : : add ( m_pQueryOnlyIfUsersSelectedCheck , __tr2qs ( " This will enable the action only if there are " \
" selected users in the active window " ) ) ;
gl - > addMultiCellWidget ( m_pQueryOnlyIfUsersSelectedCheck , 9 , 9 , 2 , 3 ) ;
m_pWindowDccChatCheck = new KviStyledCheckBox ( __tr2qs ( " Enable in DCC Chat Windows " ) , tab ) ;
TQToolTip : : add ( m_pWindowDccChatCheck , __tr2qs ( " Check this option if this action should be enabled only when " \
" the active window is a dcc chat " ) ) ;
gl - > addMultiCellWidget ( m_pWindowDccChatCheck , 10 , 10 , 1 , 3 ) ;
l = new TQLabel ( tab ) ;
gl - > addMultiCellWidget ( l , 11 , 11 , 0 , 3 ) ;
gl - > setColStretch ( 3 , 1 ) ;
gl - > setRowStretch ( 11 , 1 ) ;
tw - > addTab ( tab , __tr2qs ( " Flags " ) ) ;
tw - > setCurrentPage ( 0 ) ;
g - > setRowStretch ( 2 , 1 ) ;
g - > setColStretch ( 1 , 1 ) ;
KviPointerHashTableIterator < TQString , KviActionCategory > it ( * ( KviActionManager : : instance ( ) - > categories ( ) ) ) ;
while ( KviActionCategory * ac = it . current ( ) )
{
m_pCategoryCombo - > insertItem ( ac - > visibleName ( ) + " ( " + ac - > name ( ) + " ) " ) ;
+ + it ;
}
}
KviSingleActionEditor : : ~ KviSingleActionEditor ( )
{
}
void KviSingleActionEditor : : channelQueryOrConsoleWindowCheckToggled ( bool )
{
m_pChannelOnlyIfUsersSelectedCheck - > setEnabled ( m_pWindowChannelCheck - > isChecked ( ) ) ;
m_pChannelOnlyIfUsersSelectedCheck - > setChecked ( false ) ;
m_pQueryOnlyIfUsersSelectedCheck - > setEnabled ( m_pWindowQueryCheck - > isChecked ( ) ) ;
m_pQueryOnlyIfUsersSelectedCheck - > setChecked ( false ) ;
m_pConsoleOnlyIfUsersSelectedCheck - > setEnabled ( m_pWindowConsoleCheck - > isChecked ( ) ) ;
m_pConsoleOnlyIfUsersSelectedCheck - > setChecked ( false ) ;
}
void KviSingleActionEditor : : needsContextCheckToggled ( bool )
{
m_pEnableAtLoginCheck - > setChecked ( false ) ;
m_pEnableAtLoginCheck - > setEnabled ( false ) ;
m_pNeedsConnectionCheck - > setChecked ( false ) ;
m_pNeedsConnectionCheck - > setEnabled ( m_pNeedsContextCheck - > isChecked ( ) ) ;
}
void KviSingleActionEditor : : needsConnectionCheckToggled ( bool )
{
m_pEnableAtLoginCheck - > setChecked ( false ) ;
m_pEnableAtLoginCheck - > setEnabled ( m_pNeedsConnectionCheck - > isChecked ( ) ) ;
}
void KviSingleActionEditor : : specificWindowsCheckToggled ( bool )
{
m_pWindowConsoleCheck - > setChecked ( false ) ;
m_pWindowChannelCheck - > setChecked ( false ) ;
m_pWindowQueryCheck - > setChecked ( false ) ;
m_pWindowDccChatCheck - > setChecked ( false ) ;
m_pQueryOnlyIfUsersSelectedCheck - > setChecked ( false ) ;
m_pChannelOnlyIfUsersSelectedCheck - > setChecked ( false ) ;
m_pConsoleOnlyIfUsersSelectedCheck - > setChecked ( false ) ;
m_pQueryOnlyIfUsersSelectedCheck - > setEnabled ( false ) ;
m_pChannelOnlyIfUsersSelectedCheck - > setEnabled ( false ) ;
m_pConsoleOnlyIfUsersSelectedCheck - > setEnabled ( false ) ;
bool b = m_pSpecificWindowsCheck - > isChecked ( ) ;
m_pWindowConsoleCheck - > setEnabled ( b ) ;
m_pWindowChannelCheck - > setEnabled ( b ) ;
m_pWindowQueryCheck - > setEnabled ( b ) ;
m_pWindowDccChatCheck - > setEnabled ( b ) ;
}
void KviSingleActionEditor : : chooseSmallIcon ( )
{
if ( ! m_pActionData ) return ;
KviImageDialog * d = new KviImageDialog ( this ) ;
int ret = d - > exec ( ) ;
TQString s = d - > selectedImage ( ) ;
delete d ;
if ( ret ! = TQDialog : : Accepted ) return ;
TQPixmap * p = g_pIconManager - > getImage ( s . utf8 ( ) . data ( ) ) ;
if ( ! p ) return ;
m_pSmallIconEdit - > setText ( s ) ;
m_pSmallIconButton - > setPixmap ( * p ) ;
}
void KviSingleActionEditor : : chooseBigIcon ( )
{
if ( ! m_pActionData ) return ;
KviImageDialog * d = new KviImageDialog ( this , TQString ( ) , KID_TYPE_ALL , KID_TYPE_FULL_PATH ) ;
int ret = d - > exec ( ) ;
TQString s = d - > selectedImage ( ) ;
delete d ;
if ( ret ! = TQDialog : : Accepted ) return ;
TQPixmap * p = g_pIconManager - > getBigIcon ( s ) ;
if ( ! p ) return ;
m_pBigIconEdit - > setText ( s ) ;
m_pBigIconButton - > setPixmap ( * p ) ;
}
void KviSingleActionEditor : : setActionData ( KviActionData * d )
{
m_pActionData = d ;
if ( d )
{
unsigned int uOldFlags = d - > m_uFlags ;
d - > m_uFlags = KviAction : : validateFlags ( d - > m_uFlags ) ;
if ( d - > m_uFlags ! = uOldFlags )
debug ( " invalid action flags in KviSingleActionEditor::setActionData(): %d fixed to %d " , uOldFlags , d - > m_uFlags ) ;
m_pNameEdit - > setText ( d - > m_szName ) ;
m_pNameEdit - > setEnabled ( true ) ;
m_pVisibleNameEdit - > setText ( d - > m_szVisibleName ) ;
m_pVisibleNameEdit - > setEnabled ( true ) ;
m_pCategoryCombo - > setEnabled ( true ) ;
int i ;
for ( i = 0 ; i < m_pCategoryCombo - > count ( ) ; i + + )
{
TQString t = m_pCategoryCombo - > text ( i ) ;
int idx = t . findRev ( ' ( ' ) ;
TQString r = t . right ( t . length ( ) - ( idx + 1 ) ) ;
TQString r2 = r . left ( r . length ( ) - 1 ) ;
r2 . stripWhiteSpace ( ) ;
if ( r2 = = d - > m_szCategory )
{
m_pCategoryCombo - > setCurrentItem ( i ) ;
break ;
}
}
if ( i = = m_pCategoryCombo - > count ( ) )
{
m_pCategoryCombo - > setCurrentItem ( 0 ) ;
}
m_pScriptEditor - > setText ( d - > m_szScriptCode ) ;
m_pScriptEditor - > setEnabled ( true ) ;
m_pKeySequenceEdit - > setText ( d - > m_szKeySequence ) ;
m_pKeySequenceEdit - > setEnabled ( true ) ;
m_pDescriptionEdit - > setText ( d - > m_szDescription ) ;
m_pDescriptionEdit - > setEnabled ( true ) ;
m_pSmallIconEdit - > setEnabled ( true ) ;
m_pBigIconEdit - > setEnabled ( true ) ;
TQPixmap * p = g_pIconManager - > getImage ( d - > m_szSmallIcon ) ;
if ( p )
{
m_pSmallIconEdit - > setText ( d - > m_szSmallIcon ) ;
m_pSmallIconButton - > setPixmap ( * p ) ;
} else {
m_pSmallIconEdit - > setText ( " " ) ;
m_pSmallIconButton - > setPixmap ( TQPixmap ( ) ) ;
}
p = g_pIconManager - > getImage ( d - > m_szBigIcon ) ;
if ( p )
{
m_pBigIconEdit - > setText ( d - > m_szBigIcon ) ;
m_pBigIconButton - > setPixmap ( * p ) ;
} else {
m_pBigIconEdit - > setText ( " " ) ;
m_pBigIconButton - > setPixmap ( TQPixmap ( ) ) ;
}
m_pSmallIconButton - > setEnabled ( true ) ;
m_pBigIconButton - > setEnabled ( true ) ;
m_pNeedsContextCheck - > setEnabled ( true ) ;
bool b = ( d - > m_uFlags & KviAction : : NeedsContext ) | | ( d - > m_uFlags & KviAction : : NeedsConnection ) ;
m_pNeedsContextCheck - > setChecked ( b ) ;
m_pNeedsConnectionCheck - > setEnabled ( b ) ;
b = ( d - > m_uFlags & KviAction : : NeedsContext ) & & ( d - > m_uFlags & KviAction : : NeedsConnection ) ;
m_pNeedsConnectionCheck - > setChecked ( b ) ;
m_pEnableAtLoginCheck - > setEnabled ( b ) ;
m_pEnableAtLoginCheck - > setChecked ( b & & ( d - > m_uFlags & KviAction : : EnableAtLogin ) ) ;
m_pSpecificWindowsCheck - > setEnabled ( true ) ;
b = d - > m_uFlags & KviAction : : InternalWindowMask ;
m_pSpecificWindowsCheck - > setChecked ( b ) ;
m_pWindowConsoleCheck - > setEnabled ( b ) ;
m_pWindowChannelCheck - > setEnabled ( b ) ;
m_pWindowQueryCheck - > setEnabled ( b ) ;
m_pWindowDccChatCheck - > setEnabled ( b ) ;
b = d - > m_uFlags & KviAction : : WindowConsole ;
m_pWindowConsoleCheck - > setChecked ( b ) ;
m_pConsoleOnlyIfUsersSelectedCheck - > setEnabled ( b ) ;
m_pConsoleOnlyIfUsersSelectedCheck - > setChecked ( b & & ( d - > m_uFlags & KviAction : : WindowOnlyIfUsersSelected ) ) ;
b = d - > m_uFlags & KviAction : : WindowChannel ;
m_pWindowChannelCheck - > setChecked ( b ) ;
m_pChannelOnlyIfUsersSelectedCheck - > setEnabled ( b ) ;
m_pChannelOnlyIfUsersSelectedCheck - > setChecked ( b & & ( d - > m_uFlags & KviAction : : WindowOnlyIfUsersSelected ) ) ;
b = d - > m_uFlags & KviAction : : WindowQuery ;
m_pWindowQueryCheck - > setChecked ( b ) ;
m_pQueryOnlyIfUsersSelectedCheck - > setEnabled ( b ) ;
m_pQueryOnlyIfUsersSelectedCheck - > setChecked ( b & & ( d - > m_uFlags & KviAction : : WindowOnlyIfUsersSelected ) ) ;
m_pWindowDccChatCheck - > setChecked ( d - > m_uFlags & KviAction : : WindowDccChat ) ;
} else {
m_pNameEdit - > setText ( " " ) ;
m_pNameEdit - > setEnabled ( false ) ;
m_pVisibleNameEdit - > setText ( " " ) ;
m_pVisibleNameEdit - > setEnabled ( false ) ;
m_pCategoryCombo - > setEnabled ( false ) ;
m_pScriptEditor - > setText ( " " ) ;
m_pScriptEditor - > setEnabled ( false ) ;
m_pKeySequenceEdit - > setText ( " " ) ;
m_pKeySequenceEdit - > setEnabled ( false ) ;
m_pDescriptionEdit - > setText ( " " ) ;
m_pDescriptionEdit - > setEnabled ( false ) ;
m_pSmallIconEdit - > setText ( " " ) ;
m_pSmallIconEdit - > setEnabled ( false ) ;
m_pBigIconEdit - > setText ( " " ) ;
m_pBigIconEdit - > setEnabled ( false ) ;
m_pSmallIconButton - > setPixmap ( TQPixmap ( ) ) ;
m_pSmallIconButton - > setEnabled ( false ) ;
m_pBigIconButton - > setPixmap ( TQPixmap ( ) ) ;
m_pBigIconButton - > setEnabled ( false ) ;
m_pNeedsContextCheck - > setChecked ( false ) ;
m_pNeedsContextCheck - > setEnabled ( false ) ;
m_pNeedsConnectionCheck - > setChecked ( false ) ;
m_pNeedsConnectionCheck - > setEnabled ( false ) ;
m_pEnableAtLoginCheck - > setChecked ( false ) ;
m_pEnableAtLoginCheck - > setEnabled ( false ) ;
m_pWindowConsoleCheck - > setChecked ( false ) ;
m_pWindowConsoleCheck - > setEnabled ( false ) ;
m_pWindowChannelCheck - > setChecked ( false ) ;
m_pWindowChannelCheck - > setEnabled ( false ) ;
m_pWindowQueryCheck - > setChecked ( false ) ;
m_pWindowQueryCheck - > setEnabled ( false ) ;
m_pWindowDccChatCheck - > setChecked ( false ) ;
m_pWindowDccChatCheck - > setEnabled ( false ) ;
m_pSpecificWindowsCheck - > setChecked ( false ) ;
m_pSpecificWindowsCheck - > setEnabled ( false ) ;
m_pQueryOnlyIfUsersSelectedCheck - > setChecked ( false ) ;
m_pChannelOnlyIfUsersSelectedCheck - > setChecked ( false ) ;
m_pConsoleOnlyIfUsersSelectedCheck - > setChecked ( false ) ;
m_pQueryOnlyIfUsersSelectedCheck - > setEnabled ( false ) ;
m_pChannelOnlyIfUsersSelectedCheck - > setEnabled ( false ) ;
m_pConsoleOnlyIfUsersSelectedCheck - > setEnabled ( false ) ;
}
}
void KviSingleActionEditor : : commit ( )
{
if ( ! m_pActionData ) return ;
TQString tmp = m_pNameEdit - > text ( ) ;
if ( tmp ! = m_pActionData - > m_szName )
{
int idx = 1 ;
while ( KviActionManager : : instance ( ) - > coreActionExists ( tmp ) | | m_pActionEditor - > actionExists ( tmp ) )
{
TQString tmp2 ;
tmp2 . setNum ( idx ) ;
tmp = m_pNameEdit - > text ( ) ;
tmp . append ( tmp2 ) ;
idx + + ;
}
}
m_pActionData - > m_szName = tmp ;
m_pScriptEditor - > getText ( m_pActionData - > m_szScriptCode ) ;
m_pActionData - > m_szVisibleName = m_pVisibleNameEdit - > text ( ) ;
m_pActionData - > m_szDescription = m_pDescriptionEdit - > text ( ) ;
m_pActionData - > m_szBigIcon = m_pBigIconEdit - > text ( ) ;
m_pActionData - > m_szSmallIcon = m_pSmallIconEdit - > text ( ) ;
m_pActionData - > m_szKeySequence = m_pKeySequenceEdit - > text ( ) ;
TQString szCat = m_pCategoryCombo - > currentText ( ) ;
int idx = szCat . findRev ( ' ) ' ) ;
if ( idx ! = - 1 ) m_pActionData - > m_szCategory = szCat . left ( idx ) ;
else m_pActionData - > m_szCategory = szCat ;
idx = m_pActionData - > m_szCategory . findRev ( ' ( ' ) ;
if ( idx ! = - 1 ) m_pActionData - > m_szCategory . remove ( 0 , idx + 1 ) ;
m_pActionData - > m_uFlags = 0 ;
if ( m_pNeedsContextCheck - > isChecked ( ) )
{
m_pActionData - > m_uFlags | = KviAction : : NeedsContext ;
if ( m_pNeedsConnectionCheck - > isChecked ( ) )
{
m_pActionData - > m_uFlags | = KviAction : : NeedsConnection ;
if ( m_pEnableAtLoginCheck - > isChecked ( ) ) m_pActionData - > m_uFlags | = KviAction : : EnableAtLogin ;
}
}
if ( m_pSpecificWindowsCheck - > isChecked ( ) )
{
if ( m_pWindowConsoleCheck - > isChecked ( ) ) m_pActionData - > m_uFlags | = KviAction : : WindowConsole ;
if ( m_pWindowChannelCheck - > isChecked ( ) ) m_pActionData - > m_uFlags | = KviAction : : WindowChannel ;
if ( m_pWindowQueryCheck - > isChecked ( ) ) m_pActionData - > m_uFlags | = KviAction : : WindowQuery ;
if ( m_pWindowDccChatCheck - > isChecked ( ) ) m_pActionData - > m_uFlags | = KviAction : : WindowDccChat ;
if ( m_pActionData - > m_uFlags & KviAction : : InternalWindowMask )
{
if ( m_pConsoleOnlyIfUsersSelectedCheck - > isChecked ( ) | |
m_pChannelOnlyIfUsersSelectedCheck - > isChecked ( ) | |
m_pQueryOnlyIfUsersSelectedCheck - > isChecked ( ) )
{
m_pActionData - > m_uFlags | = KviAction : : WindowOnlyIfUsersSelected ;
}
}
}
unsigned int uOldFlags = m_pActionData - > m_uFlags ;
m_pActionData - > m_uFlags = KviAction : : validateFlags ( m_pActionData - > m_uFlags ) ;
if ( m_pActionData - > m_uFlags ! = uOldFlags )
debug ( " invalid action flags in KviSingleActionEditor::commit(): %d fixed to %d " , uOldFlags , m_pActionData - > m_uFlags ) ;
}
KviActionEditorListView : : KviActionEditorListView ( TQWidget * pParent )
: KviTalListView ( pParent )
{
setSelectionMode ( Extended ) ;
int iWidth = visibleWidth ( ) ;
if ( iWidth < LVI_MINIMUM_CELL_WIDTH ) iWidth = LVI_MINIMUM_CELL_WIDTH ;
addColumn ( __tr2qs ( " Action " ) , iWidth ) ;
setSorting ( 0 , true ) ;
}
KviActionEditorListView : : ~ KviActionEditorListView ( )
{
}
void KviActionEditorListView : : resizeEvent ( TQResizeEvent * e )
{
KviTalListView : : resizeEvent ( e ) ;
int iWidth = visibleWidth ( ) ;
if ( iWidth < LVI_MINIMUM_CELL_WIDTH ) iWidth = LVI_MINIMUM_CELL_WIDTH ;
setColumnWidth ( 0 , iWidth ) ;
}
KviActionEditor : : KviActionEditor ( TQWidget * par )
: TQWidget ( par )
{
TQGridLayout * l = new TQGridLayout ( this , 1 , 1 , 2 , 2 ) ;
# ifdef COMPILE_USE_QT4
m_pSplitter = new TQSplitter ( Qt : : Horizontal , this ) ;
m_pSplitter - > setOpaqueResize ( false ) ;
# else
m_pSplitter = new TQSplitter ( Qt : : Horizontal , this ) ;
# endif
l - > addWidget ( m_pSplitter , 0 , 0 ) ;
KviTalVBox * box = new KviTalVBox ( m_pSplitter ) ;
m_pListView = new KviActionEditorListView ( box ) ;
//m_pListView->setMultiSelection(false);
m_pListView - > setShowSortIndicator ( true ) ;
# ifdef COMPILE_USE_QT4
m_pListView - > setFocusPolicy ( TTQ_StrongFocus ) ;
# else
m_pListView - > setFocusPolicy ( TQ_StrongFocus ) ;
# endif
connect ( m_pListView , TQT_SIGNAL ( currentChanged ( KviTalListViewItem * ) ) , this , TQT_SLOT ( currentChanged ( KviTalListViewItem * ) ) ) ;
m_pNewActionButton = new TQPushButton ( __tr2qs ( " New Action " ) , box ) ;
connect ( m_pNewActionButton , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( newAction ( ) ) ) ;
m_pDeleteActionsButton = new TQPushButton ( __tr2qs ( " Delete Actions " ) , box ) ;
connect ( m_pDeleteActionsButton , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( deleteActions ( ) ) ) ;
m_pExportActionsButton = new TQPushButton ( __tr2qs ( " Export Actions... " ) , box ) ;
connect ( m_pExportActionsButton , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( exportActions ( ) ) ) ;
box - > setSpacing ( 1 ) ;
m_pSingleActionEditor = new KviSingleActionEditor ( m_pSplitter , this ) ;
KviActionEditorListViewItem * last = 0 ;
KviActionEditorListViewItem * first = 0 ;
KviPointerHashTableIterator < TQString , KviAction > it ( * ( KviActionManager : : instance ( ) - > actions ( ) ) ) ;
while ( KviAction * a = it . current ( ) )
{
if ( a - > isKviUserActionNeverOverrideThis ( ) )
{
KviActionData * ad = new KviActionData ( a - > name ( ) ,
( ( KviKvsUserAction * ) a ) - > scriptCode ( ) ,
( ( KviKvsUserAction * ) a ) - > visibleNameCode ( ) ,
( ( KviKvsUserAction * ) a ) - > descriptionCode ( ) ,
a - > category ( ) ? a - > category ( ) - > name ( ) : KviActionManager : : categoryGeneric ( ) - > name ( ) ,
a - > bigIconString ( ) ,
( ( KviKvsUserAction * ) a ) - > smallIconString ( ) ,
a - > flags ( ) ,
a - > keySequence ( ) ,
0 ) ;
KviActionEditorListViewItem * lvi = new KviActionEditorListViewItem ( m_pListView , ad ) ;
ad - > m_pItem = lvi ;
if ( ad - > m_szName = = g_szLastEditedAction )
last = lvi ;
if ( ! first )
first = lvi ;
}
+ + it ;
}
if ( ! last ) last = first ; // try to sleect the first one then
if ( last )
{
m_pListView - > setCurrentItem ( last ) ;
currentChanged ( last ) ;
} else {
currentChanged ( 0 ) ;
}
}
KviActionEditor : : ~ KviActionEditor ( )
{
}
void KviActionEditor : : exportActions ( )
{
TQString szName = TQDir : : homeDirPath ( ) ;
if ( ! szName . endsWith ( TQString ( KVI_PATH_SEPARATOR ) ) ) szName + = KVI_PATH_SEPARATOR ;
szName + = " myactions.kvs " ;
TQString szFile ;
if ( ! KviFileDialog : : askForSaveFileName ( szFile , __tr2qs ( " Choose a Filename - KVIrc " ) , szName , TQString ( ) , true , true , true ) ) return ;
TQString szCode ;
KviActionEditorListViewItem * it = ( KviActionEditorListViewItem * ) m_pListView - > firstChild ( ) ;
while ( it )
{
if ( it - > isSelected ( ) )
{
KviActionData * a = it - > actionData ( ) ;
KviKvsUserAction : : exportToKvs ( szCode ,
a - > m_szName ,
a - > m_szScriptCode ,
a - > m_szVisibleName ,
a - > m_szDescription ,
a - > m_szCategory ,
a - > m_szBigIcon ,
a - > m_szSmallIcon ,
a - > m_uFlags ,
a - > m_szKeySequence ) ;
}
it = ( KviActionEditorListViewItem * ) ( it - > nextSibling ( ) ) ;
}
if ( ! KviFileUtils : : writeFile ( szFile , szCode ) )
{
TQMessageBox : : warning ( this , __tr2qs ( " Write Failed - KVIrc " ) , __tr2qs ( " Unable to write to the actions file. " ) , __tr2qs ( " OK " ) ) ;
}
}
void KviActionEditor : : deleteActions ( )
{
KviPointerList < KviActionEditorListViewItem > l ;
l . setAutoDelete ( false ) ;
KviActionEditorListViewItem * it = ( KviActionEditorListViewItem * ) m_pListView - > firstChild ( ) ;
while ( it )
{
if ( it - > isSelected ( ) )
l . append ( it ) ;
it = ( KviActionEditorListViewItem * ) ( it - > nextSibling ( ) ) ;
}
if ( l . isEmpty ( ) ) return ;
//if(TQMessageBox::question(this,__tr2qsf("Confirm Deletion"),__tr2qsf("Do you really want to delete the selected actions ?"),__tr2qsf("Yes"),__tr2qsf("No")) != 0)
// return;
for ( KviActionEditorListViewItem * i = l . first ( ) ; i ; i = l . next ( ) )
{
if ( m_pSingleActionEditor - > actionData ( ) = = i - > actionData ( ) )
m_pSingleActionEditor - > setActionData ( 0 ) ;
delete i ;
}
}
TQString KviActionEditor : : nameForAutomaticAction ( const TQString & szTemplate )
{
TQString ret ;
TQString szT = szTemplate ;
szT . replace ( " " , " " ) ;
szT . replace ( " . " , " _ " ) ;
int i = 1 ;
do {
KviTQString : : sprintf ( ret , " %Q%d " , & szT , i ) ;
i + + ;
} while ( actionExists ( ret ) ) ;
return ret ;
}
void KviActionEditor : : newAction ( )
{
TQString szName = nameForAutomaticAction ( __tr2qs ( " My Action " ) ) ;
TQString szVis = __tr2qs ( " My Action " ) ;
TQString szDes = __tr2qs ( " Put here a short description of your action " ) ;
szVis . prepend ( " $tr( \" " ) ;
szVis . append ( " \" ) " ) ;
szDes . prepend ( " $tr( \" " ) ;
szDes . append ( " \" ) " ) ;
KviActionData * ad = new KviActionData ( szName ,
TQString ( ) ,
szVis ,
szDes ,
KviActionManager : : categoryGeneric ( ) - > name ( ) ,
TQString ( ) ,
TQString ( ) ,
0 ,
TQString ( ) ,
0 ) ;
KviActionEditorListViewItem * lvi = new KviActionEditorListViewItem ( m_pListView , ad ) ;
ad - > m_pItem = lvi ;
m_pListView - > setCurrentItem ( lvi ) ;
currentChanged ( lvi ) ;
}
bool KviActionEditor : : actionExists ( const TQString & szName )
{
KviActionEditorListViewItem * it = ( KviActionEditorListViewItem * ) m_pListView - > firstChild ( ) ;
while ( it )
{
if ( it - > actionData ( ) - > m_szName = = szName ) return true ;
it = ( KviActionEditorListViewItem * ) ( it - > nextSibling ( ) ) ;
}
return false ;
}
void KviActionEditor : : currentChanged ( KviTalListViewItem * i )
{
if ( m_pSingleActionEditor - > actionData ( ) )
{
m_pSingleActionEditor - > commit ( ) ;
m_pSingleActionEditor - > actionData ( ) - > m_pItem - > setupForActionData ( ) ;
}
m_pListView - > update ( ) ;
KviActionEditorListViewItem * it = ( KviActionEditorListViewItem * ) i ;
if ( ! it )
{
m_pSingleActionEditor - > setActionData ( 0 ) ;
m_pDeleteActionsButton - > setEnabled ( false ) ;
m_pExportActionsButton - > setEnabled ( false ) ;
return ;
}
m_pDeleteActionsButton - > setEnabled ( true ) ;
m_pExportActionsButton - > setEnabled ( true ) ;
if ( ! it - > isSelected ( ) ) m_pListView - > setSelected ( it , true ) ;
m_pSingleActionEditor - > setActionData ( it - > actionData ( ) ) ;
g_szLastEditedAction = it - > actionData ( ) - > m_szName ;
}
void KviActionEditor : : commit ( )
{
m_pSingleActionEditor - > commit ( ) ;
// the hard part: update the actions without destroying them...
KviActionManager : : instance ( ) - > killAllKvsUserActions ( ) ;
KviActionEditorListViewItem * it = ( KviActionEditorListViewItem * ) m_pListView - > firstChild ( ) ;
while ( it )
{
KviKvsUserAction * a = KviKvsUserAction : : createInstance ( // msvc workaround
KviActionManager : : instance ( ) ,
it - > actionData ( ) - > m_szName ,
it - > actionData ( ) - > m_szScriptCode ,
it - > actionData ( ) - > m_szVisibleName ,
it - > actionData ( ) - > m_szDescription ,
it - > actionData ( ) - > m_szCategory ,
it - > actionData ( ) - > m_szBigIcon ,
it - > actionData ( ) - > m_szSmallIcon ,
it - > actionData ( ) - > m_uFlags ,
it - > actionData ( ) - > m_szKeySequence ) ;
KviActionManager : : instance ( ) - > registerAction ( a ) ;
it = ( KviActionEditorListViewItem * ) ( it - > nextSibling ( ) ) ;
}
KviCustomToolBarManager : : instance ( ) - > updateVisibleToolBars ( ) ;
}
KviActionEditorWindow : : KviActionEditorWindow ( KviFrame * lpFrm )
: KviWindow ( KVI_WINDOW_TYPE_SCRIPTEDITOR , lpFrm , " actioneditor " , 0 )
{
g_pActionEditorWindow = this ;
setFixedCaption ( __tr2qs ( " Action Editor " ) ) ;
m_pEditor = new KviActionEditor ( this ) ;
m_pBase = new TQWidget ( this ) ;
TQGridLayout * g = new TQGridLayout ( m_pBase , 1 , 4 , 4 , 4 ) ;
TQPushButton * btn = new TQPushButton ( __tr2qs ( " OK " ) , m_pBase ) ;
btn - > setMinimumWidth ( 80 ) ;
connect ( btn , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( okClicked ( ) ) ) ;
btn - > setIconSet ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_ACCEPT ) ) ) ;
g - > addWidget ( btn , 0 , 1 ) ;
btn = new TQPushButton ( __tr2qs ( " Apply " ) , m_pBase ) ;
btn - > setMinimumWidth ( 80 ) ;
connect ( btn , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( applyClicked ( ) ) ) ;
btn - > setIconSet ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_ACCEPT ) ) ) ;
g - > addWidget ( btn , 0 , 2 ) ;
btn = new TQPushButton ( __tr2qs ( " Cancel " ) , m_pBase ) ;
btn - > setMinimumWidth ( 80 ) ;
connect ( btn , TQT_SIGNAL ( clicked ( ) ) , this , TQT_SLOT ( cancelClicked ( ) ) ) ;
btn - > setIconSet ( * ( g_pIconManager - > getSmallIcon ( KVI_SMALLICON_DISCARD ) ) ) ;
g - > addWidget ( btn , 0 , 3 ) ;
g - > setColStretch ( 0 , 1 ) ;
}
KviActionEditorWindow : : ~ KviActionEditorWindow ( )
{
g_pActionEditorWindow = 0 ;
}
void KviActionEditorWindow : : okClicked ( )
{
m_pEditor - > commit ( ) ;
close ( ) ;
}
void KviActionEditorWindow : : applyClicked ( )
{
m_pEditor - > commit ( ) ;
}
void KviActionEditorWindow : : cancelClicked ( )
{
close ( ) ;
}
TQPixmap * KviActionEditorWindow : : myIconPtr ( )
{
return g_pIconManager - > getSmallIcon ( KVI_SMALLICON_SCRIPTACTION ) ;
}
void KviActionEditorWindow : : resizeEvent ( TQResizeEvent * e )
{
int hght = m_pBase - > sizeHint ( ) . height ( ) ;
m_pEditor - > setGeometry ( 0 , 0 , width ( ) , height ( ) - hght ) ;
m_pBase - > setGeometry ( 0 , height ( ) - hght , width ( ) , hght ) ;
}
void KviActionEditorWindow : : getConfigGroupName ( KviStr & szName )
{
szName = " actioneditor " ;
}
void KviActionEditorWindow : : saveProperties ( KviConfig * cfg )
{
KviWindow : : saveProperties ( cfg ) ;
cfg - > writeEntry ( " Splitter " , m_pEditor - > m_pSplitter - > sizes ( ) ) ;
}
void KviActionEditorWindow : : loadProperties ( KviConfig * cfg )
{
int w = width ( ) ;
KviWindow : : loadProperties ( cfg ) ;
KviValueList < int > def ;
def . append ( ( w * 25 ) / 100 ) ;
def . append ( ( w * 75 ) / 100 ) ;
m_pEditor - > m_pSplitter - > setSizes ( cfg - > readIntListEntry ( " Splitter " , def ) ) ;
}