You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2287 lines
47 KiB
2287 lines
47 KiB
/*
|
|
* khexedit - Versatile hex editor
|
|
* Copyright (C) 1999 Espen Sand, espensa@online.no
|
|
*
|
|
* 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.
|
|
*
|
|
* 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 <iostream>
|
|
|
|
#include <tqclipboard.h>
|
|
#include <tqdrawutil.h>
|
|
|
|
|
|
#include <tdeglobalsettings.h>
|
|
#include <tdelocale.h>
|
|
#include <tdepopupmenu.h>
|
|
#include <kdebug.h>
|
|
#include <kurldrag.h>
|
|
|
|
#include "hexdrag.h"
|
|
#include "hexerror.h"
|
|
#include "hexviewwidget.h"
|
|
|
|
//
|
|
// The usage of the WNorthWestGravity flag should make screen update
|
|
// faster (less paintEvents). I have had to add update() some places
|
|
// to ensure proper redrawing. Undefine if something goes wrong
|
|
// (i.e. not updated )
|
|
//
|
|
#define USE_NORTHWEST_GRAVITY 1
|
|
|
|
//
|
|
// I don't want to decide what is best: Drag starts when mouse is moved or
|
|
// after a timeout.
|
|
//
|
|
#define USE_DRAG_MOVEMENT 1
|
|
|
|
|
|
|
|
|
|
|
|
|
|
CDragManager::CDragManager( void )
|
|
{
|
|
mActivateMode = Movement;
|
|
mPending = false;
|
|
mTimerId = 0;
|
|
}
|
|
|
|
void CDragManager::setActivateMode( EDragActivateMode mode )
|
|
{
|
|
clear();
|
|
mActivateMode = mode; // Movement or Timer
|
|
}
|
|
|
|
void CDragManager::setup( int x, int y )
|
|
{
|
|
if( mActivateMode == Movement )
|
|
{
|
|
mOrigin.setX(x);
|
|
mOrigin.setY(y);
|
|
}
|
|
else
|
|
{
|
|
setupTimer();
|
|
}
|
|
mPending = true;
|
|
}
|
|
|
|
bool CDragManager::start( TQMouseEvent *e )
|
|
{
|
|
if( mPending == false )
|
|
{
|
|
return( false );
|
|
}
|
|
|
|
if( mActivateMode == Movement )
|
|
{
|
|
if( (mOrigin - e->pos()).manhattanLength() > TDEGlobalSettings::dndEventDelay() )
|
|
{
|
|
mPending = false;
|
|
emit startDrag( e->state() & ShiftButton ? true : false );
|
|
}
|
|
return( true );
|
|
}
|
|
else // Timer
|
|
{
|
|
if( mTimerId != 0 )
|
|
{
|
|
removeTimer();
|
|
mPending = false;
|
|
emit startDrag( e->state() & ShiftButton ? true : false );
|
|
return( true );
|
|
}
|
|
else
|
|
{
|
|
// Should never happen!
|
|
mPending = false;
|
|
return( false );
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
bool CDragManager::clear( void )
|
|
{
|
|
if( mPending == false )
|
|
{
|
|
return( false );
|
|
}
|
|
|
|
if( mActivateMode == Timer )
|
|
{
|
|
removeTimer();
|
|
}
|
|
|
|
mPending = false;
|
|
return( true );
|
|
}
|
|
|
|
void CDragManager::timerEvent( TQTimerEvent *e )
|
|
{
|
|
if( e->timerId() == mTimerId )
|
|
{
|
|
removeTimer();
|
|
if( mPending == true )
|
|
{
|
|
mPending = false;
|
|
emit startDrag( ( kapp->keyboardModifiers() & TDEApplication::ShiftModifier ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CDragManager::removeTimer( void )
|
|
{
|
|
if( mTimerId != 0 )
|
|
{
|
|
killTimer( mTimerId );
|
|
mTimerId = 0;
|
|
}
|
|
}
|
|
|
|
void CDragManager::setupTimer( void )
|
|
{
|
|
if( mTimerId != 0 )
|
|
{
|
|
killTimer( mTimerId );
|
|
mTimerId = 0;
|
|
}
|
|
mTimerId = startTimer( 500 );
|
|
}
|
|
|
|
|
|
//
|
|
// This widget will use the entire space of the parent widget
|
|
//
|
|
CHexViewWidget::CHexViewWidget( TQWidget *parent, const char *name,
|
|
CHexBuffer *hexBuffer )
|
|
: TQFrame( parent, name,
|
|
#ifdef USE_NORTHWEST_GRAVITY
|
|
TQt::WStaticContents
|
|
#else
|
|
0
|
|
#endif
|
|
), mScrollBarSize( 16 )
|
|
{
|
|
if( parent == 0 || hexBuffer == 0 ) { return; }
|
|
|
|
//
|
|
// TQt 2.0:
|
|
// -------
|
|
// I use the "CScrollBar" because sometimes (very seldom) when I
|
|
// do a mHorzScroll->hide() the mHorzScroll->isVisible() remains true
|
|
// in updateView() for a short while. I need the correct visibility
|
|
// because I have to redraw the area - due to the "WNorthWestGravity" usage.
|
|
//
|
|
// I tried to do a
|
|
// "while( mHorzScroll->isVisible() ) { mHorzScroll->hide(); }"
|
|
// but then the loop never ended. The "CScrollBar" emits a "hidden()"
|
|
// signal whenever is receives a TQHideEvent.
|
|
//
|
|
|
|
mVertScroll = new CScrollBar( TQt::Vertical, this );
|
|
if( mVertScroll == 0 ) { return; }
|
|
mHorzScroll = new CScrollBar( TQt::Horizontal, this );
|
|
if( mHorzScroll == 0 ) { return; }
|
|
mCorner = new TQWidget( this );
|
|
if( mCorner == 0 ) { return; }
|
|
connect( mHorzScroll, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changeXPos(int)) );
|
|
connect( mVertScroll, TQT_SIGNAL(valueChanged(int)), TQT_SLOT(changeYPos(int)) );
|
|
connect( mHorzScroll, TQT_SIGNAL(hidden()), TQT_SLOT(update()) );
|
|
connect( mVertScroll, TQT_SIGNAL(hidden()), TQT_SLOT(update()) );
|
|
mHorzScroll->hide();
|
|
mVertScroll->hide();
|
|
|
|
mDragManager = new CDragManager();
|
|
if( mDragManager == 0 ) { return; }
|
|
#ifdef USE_DRAG_MOVEMENT
|
|
mDragManager->setActivateMode( CDragManager::Movement );
|
|
#else
|
|
mDragManager->setActivateMode( CDragManager::Timer );
|
|
#endif
|
|
connect( mDragManager, TQT_SIGNAL(startDrag(bool)), TQT_SLOT(startDrag(bool)) );
|
|
|
|
setFrameStyle( TQFrame::WinPanel|TQFrame::Sunken );
|
|
setWFlags( WResizeNoErase );
|
|
setFocusPolicy( TQWidget::StrongFocus );
|
|
|
|
mHexBuffer = hexBuffer;
|
|
mHexBuffer->cursorReset();
|
|
|
|
mEditMode = mHexBuffer->editMode();
|
|
mShowCursor = false;
|
|
mCursorTimerId = 0;
|
|
|
|
mDocumentMenu = 0;
|
|
|
|
setTextBufferSize(); // Make sure there is a pixmap buffer
|
|
setStartX(0);
|
|
setStartY(0);
|
|
|
|
setAcceptDrops(true);
|
|
setDropHighlight(false); // Init state + frame shape
|
|
setBackgroundColor( mHexBuffer->backgroundColor() );
|
|
}
|
|
|
|
|
|
CHexViewWidget::~CHexViewWidget( void )
|
|
{
|
|
delete mVertScroll;
|
|
delete mHorzScroll;
|
|
delete mCorner;
|
|
delete mDragManager;
|
|
}
|
|
|
|
|
|
int CHexViewWidget::readFile( TQFile &file, const TQString &url, CProgress &p )
|
|
{
|
|
int errCode = mHexBuffer->readFile( file, url, p );
|
|
if( errCode != Err_Success )
|
|
{
|
|
return( errCode );
|
|
}
|
|
|
|
initFile();
|
|
return( Err_Success );
|
|
}
|
|
|
|
|
|
int CHexViewWidget::insertFile( TQFile &file, CProgress &p )
|
|
{
|
|
int errCode = mHexBuffer->insertFile( file, p );
|
|
if( errCode != Err_Success )
|
|
{
|
|
return( errCode );
|
|
}
|
|
|
|
updateWindow( true, true );
|
|
|
|
emit dataChanged();
|
|
emit cursorChanged( mHexBuffer->cursorState() );
|
|
emit layoutChanged( mLayout );
|
|
return( Err_Success );
|
|
}
|
|
|
|
|
|
int CHexViewWidget::newFile( const TQString &url )
|
|
{
|
|
int errCode = mHexBuffer->newFile( url );
|
|
if( errCode != Err_Success )
|
|
{
|
|
return( errCode );
|
|
}
|
|
|
|
initFile();
|
|
return( Err_Success );
|
|
}
|
|
|
|
|
|
int CHexViewWidget::writeFile( TQFile &file, CProgress &p )
|
|
{
|
|
int errCode = mHexBuffer->writeFile( file, p );
|
|
if( errCode == Err_Success )
|
|
{
|
|
emit fileState( mHexBuffer->fileState() );
|
|
}
|
|
return( errCode );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::closeFile( void )
|
|
{
|
|
emit fileClosed( mHexBuffer->url() );
|
|
mHexBuffer->closeFile();
|
|
initFile();
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::initFile( void )
|
|
{
|
|
setStartX(0);
|
|
setStartY(0);
|
|
|
|
mHexBuffer->cursorReset();
|
|
mHexBuffer->setLayout( mLayout );
|
|
mHexBuffer->setFont( mFontInfo );
|
|
setEditMode( mEditMode );
|
|
setColor( mColor, false );
|
|
setCursor( mCursor, false );
|
|
setMisc( mMisc );
|
|
|
|
setBackgroundColor( mHexBuffer->backgroundColor() );
|
|
setBackgroundMode( NoBackground );
|
|
|
|
updateView( true, false );
|
|
resizeEvent( 0 );
|
|
|
|
emit dataChanged();
|
|
emit cursorChanged( mHexBuffer->cursorState() );
|
|
emit fileState( mHexBuffer->fileState() );
|
|
emit encodingChanged( mHexBuffer->encoding() );
|
|
emit fileName( mHexBuffer->url(), mHexBuffer->hasFileName() );
|
|
emit bookmarkChanged( mHexBuffer->bookmarkList() );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::setBuffer( CHexBuffer *hexBuffer )
|
|
{
|
|
if( hexBuffer == 0 || mHexBuffer == hexBuffer )
|
|
{
|
|
return;
|
|
}
|
|
|
|
unselect();
|
|
unmark();
|
|
|
|
mHexBuffer = hexBuffer;
|
|
mHexBuffer->setLayout( mLayout );
|
|
mHexBuffer->setFont( mFontInfo );
|
|
setEditMode( mEditMode );
|
|
setColor( mColor, false );
|
|
setCursor( mCursor, false );
|
|
setMisc( mMisc );
|
|
|
|
if( mLayout.lockLine == false )
|
|
{
|
|
mHexBuffer->matchWidth( width() );
|
|
}
|
|
|
|
setBackgroundColor( hexBuffer->backgroundColor() );
|
|
setBackgroundMode( NoBackground );
|
|
|
|
setEditMode( mEditMode );
|
|
updateWindow();
|
|
|
|
emit dataChanged();
|
|
emit cursorChanged( mHexBuffer->cursorState() );
|
|
emit fileState( mHexBuffer->fileState() );
|
|
emit encodingChanged( mHexBuffer->encoding() );
|
|
emit layoutChanged( mLayout );
|
|
emit inputModeChanged( mHexBuffer->inputMode() );
|
|
emit fileName( mHexBuffer->url(), mHexBuffer->hasFileName() );
|
|
emit bookmarkChanged( mHexBuffer->bookmarkList() );
|
|
}
|
|
|
|
|
|
|
|
|
|
void CHexViewWidget::changeXPos( int p )
|
|
{
|
|
int dx = startX() - p;
|
|
setStartX(p);
|
|
|
|
|
|
if( TQABS(dx) < width() )
|
|
{
|
|
scroll( dx, 0, contentsRect() );
|
|
}
|
|
else
|
|
{
|
|
TQWidget::update();
|
|
}
|
|
|
|
//
|
|
// If the start position has become 0, then update the view. This
|
|
// will remove the scrollbar (if it is visible) if the textarea width
|
|
// is wider than the text. The scrollbar will then disappear under the
|
|
// mouse pointer.
|
|
//
|
|
if( startX() == 0 )
|
|
{
|
|
updateView( false, false );
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void CHexViewWidget::changeYPos( int p )
|
|
{
|
|
int dy = startY() - p;
|
|
setStartY(p);
|
|
|
|
if( TQABS( dy ) < height() )
|
|
{
|
|
scroll( 0, dy, contentsRect() );
|
|
}
|
|
else
|
|
{
|
|
TQWidget::update();
|
|
}
|
|
|
|
//
|
|
// If the start position has become 0, then update the view. This
|
|
// will remove the scrollbar (if it is visible) if the textarea height
|
|
// is taller than the text. The scrollbar will then disappear under the
|
|
// mouse pointer.
|
|
//
|
|
if( startY() == 0 )
|
|
{
|
|
updateView( false, false );
|
|
}
|
|
}
|
|
|
|
|
|
void CHexViewWidget::clipboardChanged( void )
|
|
{
|
|
disconnect(TQApplication::clipboard(),TQT_SIGNAL(dataChanged()),
|
|
this,TQT_SLOT(clipboardChanged()));
|
|
unselect();
|
|
}
|
|
|
|
void CHexViewWidget::paletteChanged( void )
|
|
{
|
|
setColor( mColor, true );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::fontChanged( void )
|
|
{
|
|
//setFont( kapp->fixedFont, true );
|
|
}
|
|
|
|
void CHexViewWidget::filter( SFilterControl &fc )
|
|
{
|
|
int errCode = mHexBuffer->filter( fc );
|
|
if( errCode == Err_Success )
|
|
{
|
|
repaint();
|
|
emit dataChanged();
|
|
emit cursorChanged( mHexBuffer->cursorState() );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::insert( SInsertData &id )
|
|
{
|
|
if( id.onCursor == false )
|
|
{
|
|
mHexBuffer->cursorGoto( id.offset, 7 );
|
|
}
|
|
SCursorConfig cc;
|
|
updateCursor( cc, true );
|
|
|
|
if( id.size == 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
TQByteArray buf( id.size );
|
|
if( buf.isNull() == true )
|
|
{
|
|
return;
|
|
}
|
|
buf.fill( 0 );
|
|
|
|
if( id.pattern.size() > 0 )
|
|
{
|
|
uint size = id.pattern.size()>buf.size() ? buf.size() : id.pattern.size();
|
|
if( id.repeatPattern == false )
|
|
{
|
|
memcpy( &buf[0], &id.pattern[0], size );
|
|
if( size < buf.size() )
|
|
{
|
|
memset( &buf[size], id.pattern[id.pattern.size()-1], buf.size()-size );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( uint i=0; i < buf.size(); i+= size )
|
|
{
|
|
uint s = i+size > buf.size() ? buf.size()-i : size;
|
|
memcpy( &buf[i], &id.pattern[0], s );
|
|
}
|
|
}
|
|
}
|
|
|
|
insert( buf );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::insert( const TQByteArray &buf )
|
|
{
|
|
if( mHexBuffer->documentPresent() == false )
|
|
{
|
|
emit pleaseOpenNewFile();
|
|
if( mHexBuffer->documentPresent() == false )
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
|
|
uint offset = mHexBuffer->cursorOffset();
|
|
int errCode = mHexBuffer->inputAtCursor( buf, 0 );
|
|
if( errCode == Err_Success )
|
|
{
|
|
updateWindow( offset, true );
|
|
emit dataChanged();
|
|
}
|
|
}
|
|
|
|
|
|
void CHexViewWidget::append( const TQByteArray &buf )
|
|
{
|
|
if( mHexBuffer->documentPresent() == false )
|
|
{
|
|
insert( buf );
|
|
}
|
|
else
|
|
{
|
|
SCursorConfig cc;
|
|
cc.emulateControlButton( true );
|
|
cursorEnd( cc );
|
|
|
|
int errCode = mHexBuffer->inputAtCursor( buf, 0 );
|
|
if( errCode == Err_Success )
|
|
{
|
|
updateWindow( true, true );
|
|
emit dataChanged();
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CHexViewWidget::valueOnCursor( TQByteArray &buf, uint size )
|
|
{
|
|
mHexBuffer->valueOnCursor( buf, size );
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::updateView( bool redraw, bool fixCursor )
|
|
{
|
|
int f2 = frameWidth() * 2;
|
|
int scrollBarCount = 0; // Number of visible scrollbars
|
|
int editWidth = 0;
|
|
int editHeight = 0;
|
|
|
|
for( uint i=0; i < 2; i++ )
|
|
{
|
|
editWidth = width() - f2; // Total available width
|
|
editHeight = height() - f2; // Total available height
|
|
int textWidth = dataWidth();
|
|
int textHeight = mHexBuffer->totalHeight();
|
|
|
|
//
|
|
// This will move the start position of the horizontal scrollbar
|
|
// to the left (if possible) if the text width is smaller than the
|
|
// edit width.
|
|
//
|
|
if( startX() > 0 )
|
|
{
|
|
int size = mVertScroll->isVisible() == true ? mScrollBarSize : 0;
|
|
if( startX() + editWidth - size > textWidth )
|
|
{
|
|
int position = textWidth - editWidth + size;
|
|
setStartX( position > 0 ? position : 0 );
|
|
#ifdef USE_NORTHWEST_GRAVITY
|
|
redraw = true;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
int tooMuchX = textWidth - editWidth;
|
|
bool horzScrollbarVisible = startX() > 0 || tooMuchX > 0 ? true : false;
|
|
if( horzScrollbarVisible == true )
|
|
{
|
|
editHeight -= mScrollBarSize;
|
|
}
|
|
|
|
|
|
//
|
|
// This will move the start position of the vertical scrollbar
|
|
// to the top (if possible) if the text height is smaller than the
|
|
// edit height.
|
|
//
|
|
if( startY() > 0 )
|
|
{
|
|
if( startY() + editHeight > textHeight )
|
|
{
|
|
int position = textHeight - editHeight;
|
|
setStartY( position > 0 ? position : 0 );
|
|
#ifdef USE_NORTHWEST_GRAVITY
|
|
redraw = true;
|
|
#endif
|
|
}
|
|
}
|
|
|
|
int tooMuchY = textHeight - editHeight;
|
|
int startLine = startY() / textHeight;
|
|
|
|
if( startLine > 0 || tooMuchY > 0 )
|
|
{
|
|
editWidth -= mScrollBarSize;
|
|
tooMuchX += mScrollBarSize;
|
|
if( horzScrollbarVisible == false && tooMuchX > 0 )
|
|
{
|
|
// Horizontal scrollbar will be visible after all.
|
|
editHeight -= mScrollBarSize;
|
|
tooMuchY += mScrollBarSize;
|
|
}
|
|
}
|
|
|
|
if( tooMuchX < startX() ) { tooMuchX = startX(); }
|
|
if( tooMuchY < startY() ) { tooMuchY = startY(); }
|
|
|
|
scrollBarCount = 0;
|
|
if( tooMuchX > 0 && documentPresent() == true )
|
|
{
|
|
mHorzScroll->blockSignals( true );
|
|
mHorzScroll->setGeometry( 0, editHeight+f2, editWidth+f2,mScrollBarSize);
|
|
mHorzScroll->setRange( 0, tooMuchX );
|
|
mHorzScroll->setValue( startX() );
|
|
mHorzScroll->setSteps(mHexBuffer->lineHeight(),editWidth-mScrollBarSize);
|
|
mHorzScroll->blockSignals( false );
|
|
if( mHorzScroll->isVisible() == false ) { mHorzScroll->show(); }
|
|
scrollBarCount ++;
|
|
}
|
|
else
|
|
{
|
|
if( mHorzScroll->isVisible() == true ) { mHorzScroll->hide(); }
|
|
}
|
|
|
|
if( tooMuchY > 0 && documentPresent() == true )
|
|
{
|
|
mVertScroll->blockSignals( true );
|
|
mVertScroll->setGeometry( editWidth+f2, 0, mScrollBarSize,editHeight+f2);
|
|
mVertScroll->setRange( 0, tooMuchY );
|
|
mVertScroll->setValue( startY() );
|
|
mVertScroll->setSteps(mHexBuffer->lineHeight(),
|
|
editHeight-mScrollBarSize );
|
|
mVertScroll->blockSignals( false );
|
|
if( mVertScroll->isVisible() == false ) { mVertScroll->show(); }
|
|
scrollBarCount ++;
|
|
}
|
|
else
|
|
{
|
|
if( mVertScroll->isVisible() == true ) { mVertScroll->hide(); }
|
|
}
|
|
|
|
if( fixCursor == true )
|
|
{
|
|
int position = mHexBuffer->cursorFixedPosition( startY(), height() );
|
|
if( position != startY() )
|
|
{
|
|
setStartY( position );
|
|
fixCursor = false;
|
|
continue;
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
|
|
|
|
if( scrollBarCount == 2 )
|
|
{
|
|
mCorner->setGeometry( editWidth+f2, editHeight+f2, mScrollBarSize,
|
|
mScrollBarSize );
|
|
mCorner->show();
|
|
}
|
|
else
|
|
{
|
|
mCorner->hide();
|
|
}
|
|
|
|
|
|
updateFrameSize();
|
|
|
|
if( redraw == true )
|
|
{
|
|
TQWidget::update();
|
|
}
|
|
}
|
|
|
|
|
|
void CHexViewWidget::setPalette( const TQPalette &p )
|
|
{
|
|
TQWidget::setPalette( p );
|
|
mCorner->setPalette( p );
|
|
mVertScroll->setPalette( p );
|
|
mHorzScroll->setPalette( p );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::setLayout( SDisplayLayout &layout )
|
|
{
|
|
mLayout = layout;
|
|
mHexBuffer->setLayout( mLayout );
|
|
updateWindow();
|
|
|
|
emit layoutChanged( mLayout );
|
|
emit cursorChanged( mHexBuffer->cursorState() );
|
|
emit textWidth( defaultWidth() );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::setInputMode( SDisplayInputMode &input )
|
|
{
|
|
mHexBuffer->setInputMode( input );
|
|
emit inputModeChanged( mHexBuffer->inputMode() );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::setCursor( const SDisplayCursor &cursor,
|
|
bool /*updateDisplay*/ )
|
|
{
|
|
mCursor = cursor;
|
|
mHexBuffer->setCursorShapeModifier( cursor.alwaysBlockShape,
|
|
cursor.thickInsertShape );
|
|
setupCursorTimer();
|
|
redrawFromOffset( mHexBuffer->cursorOffset(), false );
|
|
}
|
|
|
|
void CHexViewWidget::setColor( const SDisplayColor &color,
|
|
bool updateDisplay )
|
|
{
|
|
mColor = color;
|
|
mHexBuffer->setColor( mColor );
|
|
if( updateDisplay == true )
|
|
{
|
|
repaint();
|
|
}
|
|
}
|
|
|
|
void CHexViewWidget::setFont( const SDisplayFontInfo &fontInfo,
|
|
bool updateDisplay )
|
|
{
|
|
mFontInfo = fontInfo;
|
|
mHexBuffer->setFont( mFontInfo );
|
|
emit textWidth( defaultWidth() );
|
|
if( updateDisplay == true )
|
|
{
|
|
updateWindow();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::setMisc( SDisplayMisc &misc )
|
|
{
|
|
mMisc = misc;
|
|
mHexBuffer->setUndoLevel( misc.undoLevel );
|
|
mHexBuffer->setSoundState( misc.inputSound, misc.fatalSound );
|
|
mHexBuffer->setBookmarkVisibility( misc.bookmarkOffsetColumn,
|
|
misc.bookmarkEditor );
|
|
if( mHexBuffer->documentPresent() == true )
|
|
{
|
|
TQWidget::update();
|
|
}
|
|
}
|
|
|
|
|
|
void CHexViewWidget::setInsertMode( bool insertMode )
|
|
{
|
|
setEditMode( insertMode == true ? CHexBuffer::EditInsert :
|
|
CHexBuffer::EditReplace );
|
|
}
|
|
|
|
|
|
int CHexViewWidget::setEncoding( CConversion::EMode mode, CProgress &p )
|
|
{
|
|
int errCode = mHexBuffer->setEncoding( mode, p );
|
|
if( errCode == Err_Success )
|
|
{
|
|
repaint();
|
|
emit cursorChanged( mHexBuffer->cursorState() );
|
|
emit encodingChanged( mHexBuffer->encoding() );
|
|
}
|
|
return( errCode );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::reportEncoding( void )
|
|
{
|
|
emit encodingChanged( mHexBuffer->encoding() );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::selectAll( void )
|
|
{
|
|
setSelection( 0, true );
|
|
setSelection( mHexBuffer->documentSize(), false );
|
|
autoCopy();
|
|
emit cursorChanged( mHexBuffer->cursorState() );
|
|
}
|
|
|
|
void CHexViewWidget::unselect( void )
|
|
{
|
|
setSelection( 0, true );
|
|
emit cursorChanged( mHexBuffer->cursorState() );
|
|
}
|
|
|
|
void CHexViewWidget::unmark( void )
|
|
{
|
|
setMark( 0, 0, false );
|
|
}
|
|
|
|
|
|
int CHexViewWidget::findFirst( SSearchControl &sc )
|
|
{
|
|
int errCode = mHexBuffer->findFirst( sc );
|
|
if( errCode == Err_Success ) { updateWindow( true, false ); }
|
|
return( errCode );
|
|
}
|
|
|
|
int CHexViewWidget::findNext( SSearchControl &sc )
|
|
{
|
|
int errCode = mHexBuffer->findNext( sc );
|
|
if( errCode == Err_Success ) { updateWindow( true, false ); }
|
|
return( errCode );
|
|
}
|
|
|
|
int CHexViewWidget::findWrap( SSearchControl &sc )
|
|
{
|
|
int errCode = mHexBuffer->findWrap( sc );
|
|
if( errCode == Err_Success ) { updateWindow( true, false ); }
|
|
return( errCode );
|
|
}
|
|
|
|
int CHexViewWidget::replaceAll( SSearchControl &sc, bool init )
|
|
{
|
|
int errCode = mHexBuffer->replaceAll( sc, init );
|
|
if( errCode == Err_Success )
|
|
{
|
|
updateWindow( true, false );
|
|
emit dataChanged();
|
|
}
|
|
return( errCode );
|
|
}
|
|
|
|
int CHexViewWidget::replaceMarked( SSearchControl &sc )
|
|
{
|
|
int errCode = mHexBuffer->replaceMarked( sc );
|
|
if( errCode == Err_Success )
|
|
{
|
|
updateWindow( true, false );
|
|
emit dataChanged();
|
|
}
|
|
return( errCode );
|
|
}
|
|
|
|
int CHexViewWidget::collectStrings( CStringCollectControl &sc )
|
|
{
|
|
int errCode = mHexBuffer->collectStrings( sc );
|
|
return( errCode );
|
|
}
|
|
|
|
|
|
int CHexViewWidget::collectStatistic( SStatisticControl &sc, CProgress &p )
|
|
{
|
|
int errCode = mHexBuffer->collectStatistic( sc, p );
|
|
return( errCode );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::gotoOffset( uint offset, uint bit, bool fromCursor,
|
|
bool forward )
|
|
{
|
|
bool reverse = forward == true ? false : true;
|
|
mHexBuffer->cursorGoto( offset, bit, reverse, fromCursor );
|
|
updateWindow( true, false );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::gotoOffset( uint offset )
|
|
{
|
|
gotoOffset( offset, 7, true, true );
|
|
}
|
|
|
|
|
|
int CHexViewWidget::print( CHexPrinter &printer, CProgress &p )
|
|
{
|
|
return( mHexBuffer->print( printer, p ) );
|
|
}
|
|
|
|
|
|
uint CHexViewWidget::numPage( CHexPrinter &printer )
|
|
{
|
|
return( mHexBuffer->numPage( printer ) );
|
|
}
|
|
|
|
|
|
int CHexViewWidget::exportText( const SExportText &ex, CProgress &p )
|
|
{
|
|
return( mHexBuffer->exportText( ex, p ) );
|
|
}
|
|
|
|
|
|
int CHexViewWidget::exportHtml( const SExportHtml &ex, CProgress &p )
|
|
{
|
|
return( mHexBuffer->exportHtml( ex, p ) );
|
|
}
|
|
|
|
|
|
int CHexViewWidget::exportCArray( const SExportCArray &ex, CProgress &p )
|
|
{
|
|
return( mHexBuffer->exportCArray( ex, p ) );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::startDrag( bool asText )
|
|
{
|
|
TQByteArray buf;
|
|
if( asText == true )
|
|
{
|
|
if( mHexBuffer->copySelectedText( buf ) != Err_Success )
|
|
{
|
|
return;
|
|
}
|
|
TQDragObject *d = new TQTextDrag( buf.data(), this );
|
|
d->dragCopy();
|
|
}
|
|
else
|
|
{
|
|
if( mHexBuffer->copySelectedData( buf ) != Err_Success )
|
|
{
|
|
return;
|
|
}
|
|
TQDragObject *d = new CHexDrag( buf, this );
|
|
d->dragCopy();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::copy( void )
|
|
{
|
|
TQByteArray buf;
|
|
if( mHexBuffer->copySelectedData( buf ) != Err_Success )
|
|
{
|
|
return;
|
|
}
|
|
disconnect(TQApplication::clipboard(),TQT_SIGNAL(dataChanged()),
|
|
this,TQT_SLOT(clipboardChanged()));
|
|
//
|
|
// Note: Do no give the CHexDrag a parent != 0. The clipboard
|
|
// owns the current dragdata and will destroy it on exit or
|
|
// when it receives a new object. If the CHexDrag has a parent
|
|
// != 0, the CHexDrag object will be destroyed when the parent
|
|
// is destroyed. We will then have a double destroy situation
|
|
// when the app. is closed (=> segfault).
|
|
//
|
|
TQApplication::clipboard()->setData(new CHexDrag( buf ));
|
|
connect(TQApplication::clipboard(),TQT_SIGNAL(dataChanged()),
|
|
this,TQT_SLOT(clipboardChanged()));
|
|
}
|
|
|
|
|
|
void CHexViewWidget::copyText( int columnSegment )
|
|
{
|
|
TQByteArray buf;
|
|
if( mHexBuffer->copySelectedText( buf, columnSegment ) != Err_Success )
|
|
{
|
|
return;
|
|
}
|
|
|
|
disconnect(TQApplication::clipboard(),TQT_SIGNAL(dataChanged()),
|
|
this,TQT_SLOT(clipboardChanged()));
|
|
TQApplication::clipboard()->setText( buf.data() );
|
|
connect(TQApplication::clipboard(),TQT_SIGNAL(dataChanged()),
|
|
this,TQT_SLOT(clipboardChanged()));
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::paste( void )
|
|
{
|
|
TQMimeSource *data = TQApplication::clipboard()->data();
|
|
if( data != 0 )
|
|
{
|
|
TQByteArray buf;
|
|
if( CHexDrag::decode( data, buf ) == true )
|
|
{
|
|
insert( buf );
|
|
return;
|
|
}
|
|
|
|
TQString text;
|
|
if( TQTextDrag::decode( data, text ) == true )
|
|
{
|
|
TQByteArray buf;
|
|
if( mClipConvert.decode( buf, text ) == true )
|
|
{
|
|
insert( buf );
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void CHexViewWidget::cut( void )
|
|
{
|
|
copy(); // Always make a copy to the clipboard of what we remove.
|
|
bool success = mHexBuffer->cutSelection();
|
|
if( success == false )
|
|
{
|
|
return;
|
|
}
|
|
|
|
updateWindow( false, true );
|
|
emit dataChanged();
|
|
}
|
|
|
|
|
|
void CHexViewWidget::undo( void )
|
|
{
|
|
bool success = mHexBuffer->undo();
|
|
if( success == false )
|
|
{
|
|
return;
|
|
}
|
|
|
|
updateWindow( true, true );
|
|
emit dataChanged();
|
|
}
|
|
|
|
|
|
void CHexViewWidget::redo( void )
|
|
{
|
|
bool success = mHexBuffer->redo();
|
|
if( success == false )
|
|
{
|
|
return;
|
|
}
|
|
|
|
updateWindow( true, true );
|
|
emit dataChanged();
|
|
}
|
|
|
|
|
|
void CHexViewWidget::addBookmark( int position )
|
|
{
|
|
int errCode = mHexBuffer->addBookmark( position );
|
|
if( errCode != Err_Success )
|
|
{
|
|
if( errCode == Err_ListFull )
|
|
{
|
|
replaceBookmark();
|
|
}
|
|
return;
|
|
}
|
|
redrawFromOffset( mHexBuffer->cursorOffset(), false );
|
|
|
|
emit bookmarkChanged( mHexBuffer->bookmarkList() );
|
|
}
|
|
|
|
|
|
|
|
int CHexViewWidget::bookmarkMenu( const TQString &title )
|
|
{
|
|
TQPtrList<SCursorOffset> &list = mHexBuffer->bookmarkList();
|
|
if( list.count() == 0 )
|
|
{
|
|
return( -1 );
|
|
}
|
|
|
|
TQString text;
|
|
TDEPopupMenu *popup = new TDEPopupMenu( 0 );
|
|
popup->insertTitle( title );
|
|
for( uint i=0; i < list.count(); i++ )
|
|
{
|
|
const SCursorOffset *p = list.at( i );
|
|
if( p == 0 ) { continue; }
|
|
|
|
text.sprintf("%04X:%04X", p->offset>>16, p->offset&0x0000FFFF );
|
|
text.prepend( TQString("[%1] %2: ").arg(i+1).arg(i18n("Offset")) );
|
|
popup->insertItem( text, i );
|
|
}
|
|
|
|
TQSize s(popup->sizeHint());
|
|
TQPoint center( (width()-s.width())/2, (height()-s.height())/2 );
|
|
int position = popup->exec( mapToGlobal(center) );
|
|
delete popup;
|
|
|
|
return( position );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::removeBookmark( bool all )
|
|
{
|
|
if( all == true )
|
|
{
|
|
bool success = mHexBuffer->removeBookmark( -1 );
|
|
if( success == false )
|
|
{
|
|
return;
|
|
}
|
|
TQWidget::update(); // Redraw visisble area.
|
|
}
|
|
else
|
|
{
|
|
int position = bookmarkMenu( i18n("Remove Bookmark") );
|
|
if( position < 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
const SCursorOffset *p = mHexBuffer->bookmarkList().at(position);
|
|
uint offset = p ? p->offset : 0;
|
|
|
|
bool success = mHexBuffer->removeBookmark( position );
|
|
if( success == false )
|
|
{
|
|
return;
|
|
}
|
|
|
|
redrawFromOffset( offset, false );
|
|
}
|
|
|
|
emit bookmarkChanged( mHexBuffer->bookmarkList() );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::replaceBookmark( void )
|
|
{
|
|
TQPtrList<SCursorOffset> &list = mHexBuffer->bookmarkList();
|
|
if( list.count() == 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
int position = bookmarkMenu( i18n("Replace Bookmark") );
|
|
if( position < 0 )
|
|
{
|
|
return;
|
|
}
|
|
addBookmark( position );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::gotoBookmark( uint position )
|
|
{
|
|
TQPtrList<SCursorOffset> &list = mHexBuffer->bookmarkList();
|
|
if( position >= list.count() )
|
|
{
|
|
return;
|
|
}
|
|
|
|
SCursorOffset *p = list.at( position );
|
|
if( p == 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
mHexBuffer->cursorGoto( p->offset, p->bit );
|
|
updateWindow();
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::gotoNextBookmark( bool next )
|
|
{
|
|
TQPtrList<SCursorOffset> &list = mHexBuffer->bookmarkList();
|
|
uint offset = mHexBuffer->cursorOffset();
|
|
uint diff = ~0;
|
|
|
|
SCursorOffset *match = 0;
|
|
|
|
//
|
|
// Note: the list is unsorted.
|
|
//
|
|
if( next == true )
|
|
{
|
|
for( SCursorOffset *co = list.first(); co != 0; co = list.next() )
|
|
{
|
|
if( co->offset > offset )
|
|
{
|
|
if( co->offset-offset < diff )
|
|
{
|
|
diff = co->offset-offset;
|
|
match = co;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
for( SCursorOffset *co = list.first(); co != 0; co = list.next() )
|
|
{
|
|
if( co->offset < offset )
|
|
{
|
|
if( offset-co->offset < diff )
|
|
{
|
|
diff = offset-co->offset;
|
|
match = co;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
if( match == 0 )
|
|
{
|
|
if( next == true )
|
|
{
|
|
// Wrap: Locate entry with smallest offset.
|
|
offset = ~0;
|
|
for( SCursorOffset *co = list.first(); co != 0; co = list.next() )
|
|
{
|
|
if( co->offset < offset )
|
|
{
|
|
offset = co->offset;
|
|
match = co;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// Wrap: Locate entry with largest offset.
|
|
offset=0;
|
|
for( SCursorOffset *co = list.first(); co != 0; co = list.next() )
|
|
{
|
|
if( co->offset > offset )
|
|
{
|
|
offset = co->offset;
|
|
match = co;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( match != 0 )
|
|
{
|
|
mHexBuffer->cursorGoto( match->offset, match->bit );
|
|
updateWindow();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//
|
|
// Used to test the speed of drawing
|
|
//
|
|
#include <sys/time.h>
|
|
#include <unistd.h>
|
|
void CHexViewWidget::benchmark( void )
|
|
{
|
|
struct timeval t1, t2;
|
|
uint loop = 10;
|
|
|
|
gettimeofday( &t1, 0 );
|
|
for( uint i=0; i< loop; i++ )
|
|
{
|
|
paintText( contentsRect(), false );
|
|
}
|
|
gettimeofday( &t2, 0 );
|
|
|
|
|
|
uint area = width() * height();
|
|
uint last = (t2.tv_sec-t1.tv_sec) * 1000000 + (t2.tv_usec - t1.tv_usec);
|
|
|
|
kdDebug(1501) << "Duration: " << (float)last/ 1000000.0 << endl;
|
|
kdDebug(1501) << "Duration/loop: " << (float)last/ (1000000.0*(float)loop) << endl;
|
|
kdDebug(1501) << "Area: " << area << endl;
|
|
kdDebug(1501) << "Loop: " << loop << endl;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void CHexViewWidget::resizeEvent( TQResizeEvent * )
|
|
{
|
|
setTextBufferSize();
|
|
|
|
if( mLayout.lockLine == true )
|
|
{
|
|
updateView( false, false );
|
|
#ifdef USE_NORTHWEST_GRAVITY
|
|
paintFrame();
|
|
#endif
|
|
}
|
|
else
|
|
{
|
|
bool state = mVertScroll->isVisible();
|
|
int size = (state == true ? mScrollBarSize : 0) + frameWidth()*2;
|
|
#ifdef USE_NORTHWEST_GRAVITY
|
|
int w = dataWidth();
|
|
#endif
|
|
|
|
bool bufferChanged = mHexBuffer->matchWidth( width() - size );
|
|
updateView( false, bufferChanged );
|
|
|
|
if( mVertScroll->isVisible() != state )
|
|
{
|
|
size = (mVertScroll->isVisible() ? mScrollBarSize : 0) + frameWidth()*2;
|
|
bufferChanged = mHexBuffer->matchWidth( width() - size );
|
|
updateView( false, bufferChanged );
|
|
}
|
|
|
|
#ifdef USE_NORTHWEST_GRAVITY
|
|
if( w != dataWidth() )
|
|
{
|
|
TQWidget::update();
|
|
}
|
|
else
|
|
{
|
|
paintFrame();
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::paintEvent( TQPaintEvent *e )
|
|
{
|
|
paintText( e->rect(), true );
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::updateFrameSize( void )
|
|
{
|
|
int w = width() - (mVertScroll->isVisible() ? mScrollBarSize : 0);
|
|
if( w < 0 ) { w = 0; }
|
|
int h = height() - (mHorzScroll->isVisible() ? mScrollBarSize : 0);
|
|
if( h < 0 ) { h = 0; }
|
|
|
|
setFrameRect( TQRect(0,0,w,h) );
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::paintFrame( void )
|
|
{
|
|
TQPainter paint;
|
|
paint.begin( this );
|
|
drawFrame( &paint );
|
|
paint.end();
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::drawFrame( TQPainter *p )
|
|
{
|
|
//
|
|
// 2000-01-10 Espen Sand
|
|
// I want to display the frame with a custom color whenever the widget
|
|
// accepts a drop. The setPalette() function causes quite a bit of flicker
|
|
// in the scrollbars (even when PropagationMode is NoChildren), so I
|
|
// draw the frame manually when it can accept a drop. Note that the
|
|
// code below is for the frame shape "TQFrame::WinPanel|TQFrame::Plain"
|
|
//
|
|
if( mDropHighlight == true )
|
|
{
|
|
qDrawPlainRect( p, frameRect(), TQColor("SteelBlue2"), lineWidth() );
|
|
}
|
|
else
|
|
{
|
|
TQFrame::drawFrame(p); // Use standard drawFrame
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::keyPressEvent( TQKeyEvent *e )
|
|
{
|
|
SCursorConfig cc;
|
|
cc.state = e->state();
|
|
|
|
//
|
|
// Some special actions that we have to trap here
|
|
//
|
|
if( e->state() & ControlButton )
|
|
{
|
|
switch( e->key() )
|
|
{
|
|
case Key_Space:
|
|
e->accept();
|
|
toggleEditor();
|
|
return;
|
|
break;
|
|
|
|
case Key_1:
|
|
e->accept();
|
|
cursorStep( cc, 1 );
|
|
return;
|
|
break;
|
|
|
|
case Key_2:
|
|
e->accept();
|
|
cursorStep( cc, 2 );
|
|
return;
|
|
break;
|
|
|
|
case Key_4:
|
|
e->accept();
|
|
cursorStep( cc, 4 );
|
|
return;
|
|
break;
|
|
|
|
case Key_8:
|
|
e->accept();
|
|
cursorStep( cc, 8 );
|
|
return;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if( e->state() & AltButton )
|
|
{
|
|
if( e->key() == Key_Left || e->key() == Key_Right )
|
|
{
|
|
emit pleaseStepFile( e->key() == Key_Left ? true : false );
|
|
e->accept();
|
|
}
|
|
else if( e->key() == Key_Up || e->key() == Key_Down )
|
|
{
|
|
gotoNextBookmark( e->key() == Key_Down ? true : false );
|
|
e->accept();
|
|
}
|
|
else
|
|
{
|
|
e->ignore();
|
|
}
|
|
return;
|
|
}
|
|
|
|
switch ( e->key() )
|
|
{
|
|
case Key_Left:
|
|
cursorLeft( cc );
|
|
break;
|
|
|
|
case Key_Right:
|
|
cursorRight( cc );
|
|
break;
|
|
|
|
case Key_Up:
|
|
cursorUp( cc );
|
|
break;
|
|
|
|
case Key_Down:
|
|
cursorDown( cc );
|
|
break;
|
|
|
|
case Key_Home:
|
|
cursorHome( cc );
|
|
break;
|
|
|
|
case Key_End:
|
|
cursorEnd( cc );
|
|
break;
|
|
|
|
case Key_Next:
|
|
cursorPageDown( cc );
|
|
break;
|
|
|
|
case Key_Prior:
|
|
cursorPageUp( cc );
|
|
break;
|
|
|
|
case Key_Insert:
|
|
cursorInsert( cc );
|
|
break;
|
|
|
|
case Key_Delete:
|
|
cursorDelete( cc );
|
|
break;
|
|
|
|
case Key_Backspace:
|
|
cursorBackspace( cc );
|
|
break;
|
|
|
|
default:
|
|
if( (e->text()[0]).isPrint() == true )
|
|
{
|
|
cursorInput( TQString(e->text())[0] );
|
|
}
|
|
break;
|
|
}
|
|
|
|
e->accept();
|
|
}
|
|
|
|
|
|
void CHexViewWidget::keyReleaseEvent( TQKeyEvent *e )
|
|
{
|
|
if( ( e->state() & ShiftButton ) && shiftButtonState() == false )
|
|
{
|
|
//
|
|
// The shift button was pressed when event was triggered, but is
|
|
// now released. I use this as a sign to copy selected data to the
|
|
// clipboard.
|
|
//
|
|
autoCopy();
|
|
}
|
|
}
|
|
|
|
|
|
void CHexViewWidget::mousePressEvent( TQMouseEvent *e )
|
|
{
|
|
//
|
|
// The RMB popup menu is managed by the KContextMenuManager
|
|
//
|
|
|
|
if( e->button() == TQt::LeftButton )
|
|
{
|
|
if( e->state() & ControlButton )
|
|
{
|
|
if( KContextMenuManager::showOnButtonPress() == true
|
|
&& mDocumentMenu != 0 )
|
|
{
|
|
mDocumentMenu->popup( e->globalPos() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
bool cellLevel = mMisc.cursorJump == false;
|
|
setCursorPosition( e->x(), e->y(), true, cellLevel );
|
|
}
|
|
}
|
|
else if( e->button() == TQt::MidButton )
|
|
{
|
|
paste();
|
|
}
|
|
|
|
}
|
|
|
|
void CHexViewWidget::mouseMoveEvent( TQMouseEvent *e )
|
|
{
|
|
if( e->state() & TQt::LeftButton )
|
|
{
|
|
if( mDragManager->start( e ) == false )
|
|
{
|
|
bool cellLevel = mMisc.cursorJump == false||e->state() & ControlButton;
|
|
setCursorPosition( e->x(), e->y(), false, cellLevel );
|
|
}
|
|
}
|
|
}
|
|
|
|
void CHexViewWidget::mouseReleaseEvent( TQMouseEvent *e )
|
|
{
|
|
//
|
|
// The RMB popup menu is managed by the KContextMenuManager
|
|
//
|
|
|
|
if( e->button() == TQt::LeftButton )
|
|
{
|
|
if( e->state() & ControlButton )
|
|
{
|
|
if( KContextMenuManager::showOnButtonPress() == false
|
|
&& mDocumentMenu != 0 )
|
|
{
|
|
mDocumentMenu->popup( e->globalPos() );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if( mDragManager->clear() == true )
|
|
{
|
|
// Remove any selection
|
|
SCursorConfig cc;
|
|
cc.setKeepSelection( false );
|
|
updateCursor( cc, true );
|
|
}
|
|
else
|
|
{
|
|
mHexBuffer->cursorResetEditArea();
|
|
autoCopy();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::wheelEvent( TQWheelEvent *e )
|
|
{
|
|
if( mVertScroll->isVisible() == true )
|
|
{
|
|
TQApplication::sendEvent( mVertScroll, e );
|
|
}
|
|
}
|
|
|
|
|
|
void CHexViewWidget::dragEnterEvent( TQDragEnterEvent *e )
|
|
{
|
|
if( TQTextDrag::canDecode(e) || CHexDrag::canDecode(e) ||
|
|
KURLDrag::canDecode(e))
|
|
{
|
|
e->accept();
|
|
setDropHighlight( true );
|
|
}
|
|
}
|
|
|
|
|
|
void CHexViewWidget::dragLeaveEvent( TQDragLeaveEvent * )
|
|
{
|
|
setDropHighlight( false );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::dragMoveEvent( TQDragMoveEvent *e )
|
|
{
|
|
//
|
|
// Move the cursor if we are dragging (readable) text or binary
|
|
// data. Note: the TQTextDrag::canDecode() will return true if we
|
|
// are dragging a file so we have to test for KURLDrag::canDecode()
|
|
// first.
|
|
//
|
|
|
|
if( KURLDrag::canDecode(e) == true )
|
|
{
|
|
return;
|
|
}
|
|
|
|
if( TQTextDrag::canDecode(e) == true || CHexDrag::canDecode(e) == true )
|
|
{
|
|
int x = startX() + e->pos().x();
|
|
int y = startY() + e->pos().y();
|
|
if( mHexBuffer->setCursorPosition( x, y, false, false ) == true )
|
|
{
|
|
SCursorConfig cc;
|
|
cc.setKeepSelection( true );
|
|
updateCursor( cc, false, false );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void CHexViewWidget::dropEvent( TQDropEvent *e )
|
|
{
|
|
TQMimeSource &m = *(TQDropEvent*)e;
|
|
setDropHighlight( false );
|
|
|
|
KURL::List list;
|
|
if( KURLDrag::decode( &m, list ) == true )
|
|
{
|
|
//
|
|
// This widget can not itself open a file so it will simply pass
|
|
// the request to a parent that can (hopefully) do this
|
|
//
|
|
for( KURL::List::ConstIterator it = list.begin(); it != list.end(); it++ )
|
|
{
|
|
emit pleaseOpenFile( (*it).url(), true, 0 );
|
|
}
|
|
return;
|
|
}
|
|
|
|
TQByteArray buf;
|
|
if( CHexDrag::decode( &m, buf ) == true )
|
|
{
|
|
insert( buf );
|
|
return;
|
|
}
|
|
|
|
TQString text;
|
|
if( TQTextDrag::decode( &m, text ) == true )
|
|
{
|
|
bool success = mClipConvert.decode( buf, text );
|
|
if( success == true )
|
|
{
|
|
insert( buf );
|
|
}
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
void CHexViewWidget::showEvent( TQShowEvent * )
|
|
{
|
|
// Currently we do nothing here.
|
|
}
|
|
|
|
|
|
|
|
|
|
void CHexViewWidget::timerEvent( TQTimerEvent *e )
|
|
{
|
|
if( e->timerId() == mCursorTimerId )
|
|
{
|
|
if( hasFocus() == true )
|
|
{
|
|
if( mCursor.alwaysVisible == true )
|
|
{
|
|
mShowCursor = true;
|
|
}
|
|
else
|
|
{
|
|
mShowCursor = mShowCursor == true ? false : true;
|
|
}
|
|
}
|
|
else if( mCursor.focusMode == SDisplayCursor::hide )
|
|
{
|
|
mShowCursor = false;
|
|
}
|
|
else if( mCursor.focusMode == SDisplayCursor::stopBlinking )
|
|
{
|
|
mShowCursor = true;
|
|
}
|
|
else
|
|
{
|
|
mShowCursor = mShowCursor == true ? false : true;
|
|
}
|
|
mHexBuffer->setShowCursor( mShowCursor );
|
|
paintCursor( CHexBuffer::cursor_curr );
|
|
}
|
|
}
|
|
|
|
void CHexViewWidget::focusInEvent( TQFocusEvent * )
|
|
{
|
|
setupCursorTimer();
|
|
paintCursor( CHexBuffer::cursor_curr );
|
|
}
|
|
|
|
void CHexViewWidget::focusOutEvent( TQFocusEvent * )
|
|
{
|
|
if( mCursor.focusMode != SDisplayCursor::ignore )
|
|
{
|
|
setupCursorTimer();
|
|
paintCursor( CHexBuffer::cursor_curr );
|
|
}
|
|
}
|
|
|
|
|
|
void CHexViewWidget::setSelection( uint offset, bool init )
|
|
{
|
|
bool selectionChanged = mHexBuffer->selectionSet( offset, init );
|
|
if( selectionChanged == true )
|
|
{
|
|
uint off1, off2;
|
|
mHexBuffer->selectionStartChange( off1, off2 );
|
|
if( off1 != off2 )
|
|
{
|
|
redrawInterval( off1, off2 );
|
|
}
|
|
mHexBuffer->selectionStopChange( off1, off2 );
|
|
if( off1 != off2 )
|
|
{
|
|
redrawInterval( off1, off2 );
|
|
}
|
|
}
|
|
mHexBuffer->selectionSyncronize();
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::setMark( uint offset, uint size, bool moveCursor )
|
|
{
|
|
bool changed;
|
|
if( size == 0 )
|
|
{
|
|
changed = mHexBuffer->markRemove();
|
|
}
|
|
else
|
|
{
|
|
mHexBuffer->markSet( offset, size );
|
|
if( moveCursor == true )
|
|
{
|
|
changed = false;
|
|
gotoOffset( offset, 7, false, true );
|
|
}
|
|
else
|
|
{
|
|
changed = true;
|
|
}
|
|
}
|
|
|
|
if( changed == true )
|
|
{
|
|
uint off1, off2;
|
|
mHexBuffer->markStartChange( off1, off2 );
|
|
if( off1 != off2 )
|
|
{
|
|
redrawInterval( off1, off2 );
|
|
}
|
|
|
|
mHexBuffer->markStopChange( off1, off2 );
|
|
if( off1 != off2 )
|
|
{
|
|
redrawInterval( off1, off2 );
|
|
}
|
|
}
|
|
mHexBuffer->markSyncronize();
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::setCursorPosition(int x, int y, bool init, bool cellLevel)
|
|
{
|
|
x += startX();
|
|
y += startY();
|
|
|
|
if( mHexBuffer->setCursorPosition( x, y, init, cellLevel ) == false )
|
|
{
|
|
if( init == true )
|
|
{
|
|
unselect();
|
|
unmark();
|
|
}
|
|
}
|
|
else if( init == false )
|
|
{
|
|
SCursorConfig cc;
|
|
cc.setKeepSelection( true );
|
|
updateCursor( cc, false );
|
|
}
|
|
else
|
|
{
|
|
SCursorConfig cc;
|
|
if( mHexBuffer->cursorInsideSelection() == true )
|
|
{
|
|
mDragManager->setup( x - startX(), y - startY() );
|
|
cc.setKeepSelection( true );
|
|
updateCursor( cc, true, false );
|
|
}
|
|
else
|
|
{
|
|
cc.setKeepSelection( false );
|
|
updateCursor( cc, true );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::redrawInterval( uint startOffset, uint stopOffset )
|
|
{
|
|
//
|
|
// Can be improved, I repaint the entire line even if the offsets
|
|
// only specify one byte.
|
|
//
|
|
uint lineStart = mHexBuffer->calculateLine( startOffset );
|
|
uint lineStop = mHexBuffer->calculateLine( stopOffset );
|
|
if( lineStart <= lineStop )
|
|
{
|
|
redrawLines( lineStart, lineStop - lineStart + 1 );
|
|
}
|
|
else
|
|
{
|
|
redrawLines( lineStop, lineStart - lineStop + 1 );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::redrawLines( uint docLine, int numLine )
|
|
{
|
|
int lineHeight = mHexBuffer->lineHeight();
|
|
int lineOffset = startY() / lineHeight;
|
|
|
|
// FIXME: startY() should return uint
|
|
if( (uint)lineOffset > docLine )
|
|
{
|
|
numLine -= (lineOffset-docLine);
|
|
if( numLine <= 0 ) { return; }
|
|
docLine = lineOffset;
|
|
}
|
|
|
|
int t = docLine * lineHeight - startY() + frameWidth();
|
|
if( mEditMode == CHexBuffer::EditInsert )
|
|
{
|
|
TQRect r = contentsRect();
|
|
r.setTop( t );
|
|
paintText( contentsRect().intersect( r ), false );
|
|
}
|
|
else
|
|
{
|
|
int h = (numLine + (startY() % lineHeight ? 1 : 0)) * lineHeight;
|
|
TQRect r( contentsRect().left(), t, contentsRect().width(), h );
|
|
paintText( contentsRect().intersect( r ), false );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::redrawFromOffset( uint offset, bool finishWindow )
|
|
{
|
|
int lineHeight = mHexBuffer->lineHeight();
|
|
uint docLine = mHexBuffer->calculateLine( offset );
|
|
|
|
int t = docLine * lineHeight - startY() + frameWidth();
|
|
if( finishWindow == true )
|
|
{
|
|
TQRect r = contentsRect();
|
|
r.setTop( t );
|
|
paintText( contentsRect().intersect( r ), false );
|
|
}
|
|
else
|
|
{
|
|
int h = t + lineHeight;
|
|
TQRect r( contentsRect().left(), t, contentsRect().width(), h );
|
|
paintText( contentsRect().intersect( r ), false );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void CHexViewWidget::paintText( const TQRect &rect, bool expand )
|
|
{
|
|
TQRect r = rect;
|
|
|
|
if( expand == true )
|
|
{
|
|
#ifdef USE_NORTHWEST_GRAVITY
|
|
r.setLeft( r.left() - frameWidth() );
|
|
r.setTop( r.top() - frameWidth() );
|
|
#endif
|
|
}
|
|
|
|
if( contentsRect().contains( r ) == false )
|
|
{
|
|
paintFrame();
|
|
if( r.left() < frameWidth() ) { r.setLeft( frameWidth() ); }
|
|
if( r.top() < frameWidth() ) { r.setTop( frameWidth() ); }
|
|
}
|
|
|
|
int maxX = width() - frameWidth() - 1 -
|
|
(mVertScroll->isVisible() ? mScrollBarSize : 0);
|
|
int maxY = height() - frameWidth() - 1 -
|
|
(mHorzScroll->isVisible() ? mScrollBarSize : 0);
|
|
|
|
if( r.right() > maxX ) { r.setRight( maxX ); }
|
|
if( r.bottom() > maxY ) { r.setBottom( maxY ); }
|
|
|
|
TQPainter paint( &mTextBuffer );
|
|
paint.setFont( mHexBuffer->font() );
|
|
|
|
int lineHeight = mHexBuffer->lineHeight();
|
|
int docLine = (startY() + r.y() - frameWidth()) / lineHeight;
|
|
if( docLine < 0 ) { docLine = 0; }
|
|
int y = docLine * lineHeight - startY();
|
|
int yMax = r.height();
|
|
int xMax = r.x() + r.width();
|
|
|
|
y += frameWidth();
|
|
|
|
int s = 0;
|
|
int d = r.y()-y;
|
|
int h;
|
|
while( yMax > 0 )
|
|
{
|
|
mHexBuffer->drawText( paint, docLine, startX()-frameWidth(), r.x(), xMax );
|
|
|
|
if( d != 0 )
|
|
{
|
|
h = lineHeight - d;
|
|
if( h > yMax ) { h = yMax; }
|
|
}
|
|
else
|
|
{
|
|
h = yMax > lineHeight ? lineHeight : yMax;
|
|
}
|
|
bitBlt( this, r.x(), r.y()+s, &mTextBuffer, r.x(), d, r.width(), h );
|
|
|
|
s += h;
|
|
yMax -= h;
|
|
docLine += 1;
|
|
d = 0;
|
|
}
|
|
paint.end();
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::paintCursor( int cursorMode )
|
|
{
|
|
TQPainter paint;
|
|
paint.begin( &mTextBuffer );
|
|
paint.setFont( mHexBuffer->font() );
|
|
|
|
int f = frameWidth();
|
|
|
|
if( cursorMode == CHexBuffer::cursor_prev )
|
|
{
|
|
int line = mHexBuffer->prevCursorLine();
|
|
SCursorPosition p;
|
|
|
|
mHexBuffer->prevCursor( CHexBuffer::edit_primary, p );
|
|
mHexBuffer->drawText( paint, line, startX(), p.x, p.x + p.w );
|
|
if( p.y + p.h + f > contentsRect().bottom() )
|
|
p.h = contentsRect().bottom() - p.y - f + 1;
|
|
bitBlt( this, p.x+f, p.y+f, &mTextBuffer, p.x, 0, p.w, p.h );
|
|
|
|
mHexBuffer->prevCursor( CHexBuffer::edit_secondary, p );
|
|
mHexBuffer->drawText( paint, line, startX(), p.x, p.x + p.w );
|
|
if( p.y + p.h + f > contentsRect().bottom() )
|
|
p.h = contentsRect().bottom() - p.y - f + 1;
|
|
bitBlt( this, p.x+f, p.y+f, &mTextBuffer, p.x, 0, p.w, p.h );
|
|
}
|
|
else
|
|
{
|
|
int line = mHexBuffer->cursorLine();
|
|
SCursorPosition p;
|
|
|
|
mHexBuffer->currCursor( CHexBuffer::edit_primary, p );
|
|
mHexBuffer->drawText( paint, line, startX(), p.x, p.x + p.w );
|
|
if( p.y + p.h + f > contentsRect().bottom() )
|
|
p.h = contentsRect().bottom() - p.y - f + 1;
|
|
bitBlt( this, p.x+f, p.y+f, &mTextBuffer, p.x, 0, p.w, p.h );
|
|
|
|
mHexBuffer->currCursor( CHexBuffer::edit_secondary, p );
|
|
mHexBuffer->drawText( paint, line, startX(), p.x, p.x + p.w );
|
|
if( p.y + p.h + f > contentsRect().bottom() )
|
|
p.h = contentsRect().bottom() - p.y - f + 1;
|
|
bitBlt( this, p.x+f, p.y+f, &mTextBuffer, p.x, 0, p.w, p.h );
|
|
}
|
|
|
|
paint.end();
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void CHexViewWidget::updateCursor( SCursorConfig &cc, bool always,
|
|
bool touchSelection )
|
|
{
|
|
if( mHexBuffer->cursorChanged() == false && always == false )
|
|
{
|
|
return;
|
|
}
|
|
|
|
//
|
|
// Make blinking (and perhaps invisible) cursor visible
|
|
//
|
|
setupCursorTimer();
|
|
|
|
//
|
|
// Clear cursor at old location
|
|
//
|
|
paintCursor( CHexBuffer::cursor_prev );
|
|
|
|
//
|
|
// Compute the new position of the vertical scroll bar.
|
|
//
|
|
int position, h;
|
|
if( cc.controlButton() == true )
|
|
{
|
|
//
|
|
// The cursor should stay fixed (if possible) in the window while
|
|
// the text is scrolled (e.g., PageUp/Down behavior). The position
|
|
// of the vertical scrollbar must change just as much as the cursor
|
|
// has changed in the vertical direction.
|
|
//
|
|
h = frameWidth()*2;
|
|
h += mHorzScroll->isVisible() == false ? 0 : mScrollBarSize;
|
|
position = mHexBuffer->cursorFixedPosition( startY(), height()-h );
|
|
changeYPos( position );
|
|
}
|
|
else
|
|
{
|
|
h = frameWidth()*2;
|
|
h += mHorzScroll->isVisible() == false ? 0 : mScrollBarSize;
|
|
position = mHexBuffer->cursorChangePosition( startY(), height()-h );
|
|
changeYPos( position );
|
|
}
|
|
|
|
//
|
|
// Paint cursor at new location and update the vertical scroll bar.
|
|
//
|
|
paintCursor( CHexBuffer::cursor_curr );
|
|
mVertScroll->blockSignals( true );
|
|
mVertScroll->setValue( position );
|
|
mVertScroll->blockSignals( false );
|
|
|
|
if( touchSelection == true )
|
|
{
|
|
setSelection( mHexBuffer->cursorOffset(), cc.removeSelection() );
|
|
unmark();
|
|
}
|
|
emit cursorChanged( mHexBuffer->cursorState() );
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::toggleEditor( void )
|
|
{
|
|
bool success = mHexBuffer->toggleEditor();
|
|
if( success == false )
|
|
{
|
|
return;
|
|
}
|
|
|
|
SCursorConfig cc;
|
|
updateCursor( cc, true );
|
|
redrawFromOffset( mHexBuffer->cursorOffset(), false );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::cursorStep( SCursorConfig &cc, uint stepSize )
|
|
{
|
|
mHexBuffer->cursorStep( stepSize, cc.altButton() ? false : true, true );
|
|
cc.emulateControlButton( false );
|
|
updateCursor( cc );
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::cursorLeft( SCursorConfig &cc )
|
|
{
|
|
bool cellLevel = mMisc.cursorJump == false || cc.controlButton();
|
|
cc.emulateControlButton( false );
|
|
mHexBuffer->cursorLeft( cellLevel );
|
|
updateCursor( cc, cellLevel );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::cursorRight( SCursorConfig &cc )
|
|
{
|
|
bool cellLevel = mMisc.cursorJump == false || cc.controlButton();
|
|
cc.emulateControlButton( false );
|
|
mHexBuffer->cursorRight( cellLevel );
|
|
updateCursor( cc, cellLevel );
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::cursorUp( SCursorConfig &cc )
|
|
{
|
|
mHexBuffer->cursorUp( 1 );
|
|
updateCursor( cc );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::cursorDown( SCursorConfig &cc )
|
|
{
|
|
mHexBuffer->cursorDown( 1 );
|
|
updateCursor( cc );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::cursorHome( SCursorConfig &cc )
|
|
{
|
|
mHexBuffer->cursorHome( cc.controlButton() );
|
|
updateCursor( cc );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::cursorEnd( SCursorConfig &cc )
|
|
{
|
|
mHexBuffer->cursorEnd( cc.controlButton() );
|
|
updateCursor( cc );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::cursorPageDown( SCursorConfig &cc )
|
|
{
|
|
mHexBuffer->cursorDown( height() / mHexBuffer->lineHeight() );
|
|
cc.emulateControlButton( true );
|
|
updateCursor( cc );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::cursorPageUp( SCursorConfig &cc )
|
|
{
|
|
mHexBuffer->cursorUp( height() / mHexBuffer->lineHeight() );
|
|
cc.emulateControlButton( true );
|
|
updateCursor( cc );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::cursorInsert( SCursorConfig &/*cc*/ )
|
|
{
|
|
// Toggle mode
|
|
setEditMode( mEditMode == CHexBuffer::EditInsert ?
|
|
CHexBuffer::EditReplace : CHexBuffer::EditInsert );
|
|
}
|
|
|
|
|
|
|
|
void CHexViewWidget::cursorDelete( SCursorConfig &/*cc*/ )
|
|
{
|
|
int numLine = mHexBuffer->numLines();
|
|
|
|
bool success = mHexBuffer->removeAtCursor( false );
|
|
if( success == false )
|
|
{
|
|
return;
|
|
}
|
|
|
|
updateWindow( numLine == mHexBuffer->numLines() ? false : true, true );
|
|
emit dataChanged();
|
|
}
|
|
|
|
|
|
void CHexViewWidget::cursorBackspace( SCursorConfig &/*cc*/ )
|
|
{
|
|
int numLine = mHexBuffer->numLines();
|
|
|
|
bool success = mHexBuffer->removeAtCursor( true );
|
|
if( success == false )
|
|
{
|
|
return;
|
|
}
|
|
|
|
updateWindow( numLine == mHexBuffer->numLines() ? false : true, true );
|
|
emit dataChanged();
|
|
}
|
|
|
|
|
|
void CHexViewWidget::cursorInput( TQChar c )
|
|
{
|
|
uint cursorLine = mHexBuffer->cursorLine();
|
|
bool success = mHexBuffer->inputAtCursor( c );
|
|
if( success == false )
|
|
{
|
|
return;
|
|
}
|
|
|
|
updateWindow( cursorLine );
|
|
emit dataChanged();
|
|
}
|
|
|
|
|
|
void CHexViewWidget::setEditMode( CHexBuffer::EEditMode mode )
|
|
{
|
|
mEditMode = mode;
|
|
mHexBuffer->setEditMode( mEditMode, mCursor.alwaysBlockShape,
|
|
mCursor.thickInsertShape );
|
|
setupCursorTimer();
|
|
|
|
//
|
|
// This will redraw the current line (which contains the cursor)
|
|
//
|
|
redrawFromOffset( mHexBuffer->cursorOffset(), false );
|
|
emit editMode( mEditMode );
|
|
}
|
|
|
|
|
|
void CHexViewWidget::setDropHighlight( bool dropHighlight )
|
|
{
|
|
mDropHighlight = dropHighlight;
|
|
if( mDropHighlight == true )
|
|
{
|
|
//
|
|
// 2000-01-10 Espen Sand
|
|
// Highlight. I have reimplemented TQFrame::drawFrame(TQPainter *)
|
|
// to support a custom frame color. I assume the frame shape is
|
|
// "TQFrame::WinPanel|TQFrame::Plain" in that function.
|
|
//
|
|
setFrameStyle( TQFrame::WinPanel|TQFrame::Plain );
|
|
}
|
|
else
|
|
{
|
|
setFrameStyle( TQFrame::WinPanel|TQFrame::Sunken );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
#include "hexviewwidget.moc"
|