diff options
Diffstat (limited to 'khexedit/lib')
101 files changed, 13638 insertions, 0 deletions
diff --git a/khexedit/lib/Makefile.am b/khexedit/lib/Makefile.am new file mode 100644 index 0000000..c0c92cc --- /dev/null +++ b/khexedit/lib/Makefile.am @@ -0,0 +1,39 @@ +SUBDIRS = controller codecs + +INCLUDES = $(all_includes) + +METASOURCES = AUTO + +# this library is used by the kbytesedit part and the khepart part +lib_LTLIBRARIES = libkhexeditcommon.la +libkhexeditcommon_la_LDFLAGS = $(all_libraries) -no-undefined +libkhexeditcommon_la_LIBADD = controller/libkcontroller.la codecs/libkhecodecs.la $(LIB_KDECORE) +libkhexeditcommon_la_SOURCES = kcolumn.cpp kbordercolumn.cpp koffsetcolumn.cpp \ + kbuffercolumn.cpp kvaluecolumn.cpp kcharcolumn.cpp \ + kcolumnsview.cpp khexedit.cpp kbytesedit.cpp \ + koffsetformat.cpp \ + kdatabuffer.cpp kwrappingrobuffer.cpp \ + kplainbuffer.cpp kfixedsizebuffer.cpp kbigbuffer.cpp \ + kbuffercursor.cpp kbufferlayout.cpp kbufferranges.cpp \ + kcursor.cpp kbufferdrag.cpp \ + kwordbufferservice.cpp \ + ksectionlist.cpp kcoordrangelist.cpp \ + kbordercoltextexport.cpp koffsetcoltextexport.cpp \ + kbuffercoltextexport.cpp kvaluecoltextexport.cpp kcharcoltextexport.cpp + +# no public API for a direct use by now +noinst_HEADERS = kcolumn.h kbordercolumn.h koffsetcolumn.h \ + kbuffercolumn.h kvaluecolumn.h kcharcolumn.h \ + kbytecodec.h koffsetformat.h khexedit_export.h \ + kbuffercursor.h kbufferlayout.h kbufferranges.h \ + kbuffercoord.h kselection.h \ + kcursor.h kbufferdrag.h \ + kcoordrange.h ksectionlist.h kcoordrangelist.h \ + khechar.h kcharcodec.h \ + kcoltextexport.h kbordercoltextexport.h koffsetcoltextexport.h \ + kbuffercoltextexport.h kvaluecoltextexport.h kcharcoltextexport.h \ + kadds.h khe.h krange.h ksection.h \ + kwordbufferservice.h \ + kcolumnsview.h khexedit.h kbytesedit.h \ + kplainbuffer.h kfixedsizebuffer.h kbigbuffer.h \ + kdatabuffer.h kreadonlybuffer.h kwrappingrobuffer.h diff --git a/khexedit/lib/README b/khexedit/lib/README new file mode 100644 index 0000000..ad5f346 --- /dev/null +++ b/khexedit/lib/README @@ -0,0 +1,36 @@ +hex editor library +================== +part of the KHexEdit 2 project (kdenonbeta/khexedit2) +Author/Maintainer: Friedrich W. H. Kossebau <Friedrich.W.H@Kossebau.de> + + +description: +----------- +The lib is the main work of KHexEdit2. It offers +a general usable hex edit widget "KHexEdit" +that interacts with an abstract data buffer +interface called "KDataBuffer". This interface can +be subclassed to offer access to different data buffers +like paged gigabyte big files, video memory or whatever +you can imagine (hopefully). + +For those simply needing a widget for a plain array of bytes +there is the widget subclass "KBytesEdit", which hides the +databuffer interface and publically simply interacts with +arrays (like "char Array[25];"). + + +installing: +----------- +As these widgets and the databuffer interface have not got +much testing the API might not be finished. Because of that +it won't be made public available, i.e. there will be no headers +installed. + + +usage: +------ +This lib is by now only used by the KBytesEdit part, to be found +in "../parts/kbytesedit". +It is _not_ used by the current KHexEdit 1 app. This will change once +the successor app from KHexEdit2 is done.
\ No newline at end of file diff --git a/khexedit/lib/codecs/Makefile.am b/khexedit/lib/codecs/Makefile.am new file mode 100644 index 0000000..0c208b7 --- /dev/null +++ b/khexedit/lib/codecs/Makefile.am @@ -0,0 +1,15 @@ +INCLUDES = -I$(srcdir)/.. $(all_includes) + +METASOURCES = AUTO + +# +noinst_LTLIBRARIES = libkhecodecs.la +libkhecodecs_la_SOURCES = kcharcodec.cpp kbytecodec.cpp \ + ktextcharcodec.cpp kebcdic1047charcodec.cpp \ + kbinarybytecodec.cpp koctalbytecodec.cpp \ + kdecimalbytecodec.cpp khexadecimalbytecodec.cpp + +# no public API +noinst_HEADERS = ktextcharcodec.h kebcdic1047charcodec.h \ + kbinarybytecodec.h koctalbytecodec.h \ + kdecimalbytecodec.h khexadecimalbytecodec.h
\ No newline at end of file diff --git a/khexedit/lib/codecs/README b/khexedit/lib/codecs/README new file mode 100644 index 0000000..b4a0e52 --- /dev/null +++ b/khexedit/lib/codecs/README @@ -0,0 +1 @@ +This directory holds all the char codecs. All it exports is the call "createCodec()", the rest in hidden. diff --git a/khexedit/lib/codecs/kbinarybytecodec.cpp b/khexedit/lib/codecs/kbinarybytecodec.cpp new file mode 100644 index 0000000..d665a05 --- /dev/null +++ b/khexedit/lib/codecs/kbinarybytecodec.cpp @@ -0,0 +1,80 @@ +/*************************************************************************** + kbinarybytecodec.cpp - description + ------------------- + begin : Mo Nov 29 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "kbinarybytecodec.h" + +using namespace KHE; + + +void KBinaryByteCodec::encode( QString &Digits, unsigned int Pos, const unsigned char Char ) const +{ + for( unsigned char M=1<<7; M>0; M>>=1 ) + Digits.at(Pos++) = (Char & M) ? '1' : '0'; +} + +void KBinaryByteCodec::encodeShort( QString &Digits, unsigned int Pos, unsigned char Char ) const +{ + unsigned char M = 1<<7; + // find first set bit + for( ; M>0; M>>=1 ) + if( Char & M ) + break; + // now set the + for( ; M>0; M>>=1 ) + Digits.at(Pos++) = (Char & M) ? '1' : '0'; +} + + +bool KBinaryByteCodec::isValidDigit( unsigned char Digit ) const +{ + return Digit == '0' || Digit == '1'; +} + + +bool KBinaryByteCodec::turnToValue( unsigned char *Digit ) const +{ + if( isValidDigit(*Digit) ) + { + *Digit -= '0'; + return true; + } + return false; +} + + +bool KBinaryByteCodec::appendDigit( unsigned char *Byte, unsigned char Digit ) const +{ + if( turnToValue(&Digit) ) + { + unsigned char B = *Byte; + if( B < 128 ) + { + B <<= 1; + B += Digit; + *Byte = B; + return true; + } + } + return false; +} + + +void KBinaryByteCodec::removeLastDigit( unsigned char *Byte ) const +{ + *Byte >>= 1; +} diff --git a/khexedit/lib/codecs/kbinarybytecodec.h b/khexedit/lib/codecs/kbinarybytecodec.h new file mode 100644 index 0000000..d0354fa --- /dev/null +++ b/khexedit/lib/codecs/kbinarybytecodec.h @@ -0,0 +1,59 @@ +/*************************************************************************** + kbinarybytecodec.h - description + ------------------- + begin : Mo Nov 29 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBINARYBYTECODEC_H +#define KHE_KBINARYBYTECODEC_H + +// lib specific +#include "kbytecodec.h" + +namespace KHE +{ + +/** class that is able to convert codings to and from binary + * + * the buffer will be always filled up to CodingWidth, if not using shortCodingFunction + * a closing '\0' will be always added + * + *@author Friedrich W. H. Kossebau + */ + +class KBinaryByteCodec : public KByteCodec +{ + public: // API to be implemented + /** */ + virtual unsigned int encodingWidth() const { return 8; } + /** */ + virtual unsigned char digitsFilledLimit() const { return 128; } + + /** encodes the Char and writes the result to */ + virtual void encode( QString &Digits, unsigned int Pos, const unsigned char Char ) const; + /** */ + virtual void encodeShort( QString &Digits, unsigned int Pos, const unsigned char Char ) const; + /** */ + virtual bool appendDigit( unsigned char *Byte, const unsigned char Digit ) const; + /** */ + virtual void removeLastDigit( unsigned char *Byte ) const; + /** */ + virtual bool isValidDigit( const unsigned char Digit ) const; + /** */ + virtual bool turnToValue( unsigned char *Digit ) const; +}; + +} + +#endif diff --git a/khexedit/lib/codecs/kbytecodec.cpp b/khexedit/lib/codecs/kbytecodec.cpp new file mode 100644 index 0000000..dc5137f --- /dev/null +++ b/khexedit/lib/codecs/kbytecodec.cpp @@ -0,0 +1,63 @@ +/*************************************************************************** + kbytecodec.cpp - description + ------------------- + begin : Mo Nov 29 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "kbinarybytecodec.h" +#include "koctalbytecodec.h" +#include "kdecimalbytecodec.h" +#include "khexadecimalbytecodec.h" + +using namespace KHE; + + +KByteCodec *KByteCodec::createCodec( KCoding C ) +{ + KByteCodec *Codec; + switch( C ) + { + case DecimalCoding: Codec = new KDecimalByteCodec(); break; + case OctalCoding: Codec = new KOctalByteCodec(); break; + case BinaryCoding: Codec = new KBinaryByteCodec(); break; + case HexadecimalCoding: + default: Codec = new KHexadecimalByteCodec(); + } + return Codec; +} + +unsigned int KByteCodec::decode( unsigned char *Char, const QString &Digits, uint Pos ) const +{ + //kdDebug() << QString("KByteCodec::decode(%1,%2)").arg(Digits).arg(Pos) << endl; + const uint P = Pos; + + // remove leading 0s + while( Digits.at(Pos) == '0' ) { ++Pos; } + + unsigned char C = 0; + unsigned int d = encodingWidth(); + do + { + if( !appendDigit(&C,Digits.at(Pos)) ) + break; + + ++Pos; + --d; + } + while( d > 0 ); + + *Char = C; + return Pos - P; +} diff --git a/khexedit/lib/codecs/kcharcodec.cpp b/khexedit/lib/codecs/kcharcodec.cpp new file mode 100644 index 0000000..5a58320 --- /dev/null +++ b/khexedit/lib/codecs/kcharcodec.cpp @@ -0,0 +1,74 @@ +/*************************************************************************** + kcharcodec.cpp - description + ------------------- + begin : Do Nov 25 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "kcharcodec.h" +#include "ktextcharcodec.h" +#include "kebcdic1047charcodec.h" + +using namespace KHE; + + +QStringList KCharCodec::CodecNames; + +const QStringList &KCharCodec::codecNames() +{ + // first call? + if( CodecNames.isEmpty() ) + { + CodecNames = KTextCharCodec::codecNames(); + CodecNames.append( KEBCDIC1047CharCodec::codecName() ); + } + + return CodecNames; +} + + +KCharCodec *KCharCodec::createCodec( const QString &Name ) +{ + KCharCodec *Codec = 0; + + if( KTextCharCodec::codecNames().findIndex(Name) != -1 ) + Codec = KTextCharCodec::createCodec( Name ); + else if( KEBCDIC1047CharCodec::codecName() == Name ) + Codec = KEBCDIC1047CharCodec::create(); + + // ensure at least a codec + if( Codec == 0 ) + Codec = KTextCharCodec::createLocalCodec(); + + return Codec; +} + + +KCharCodec *KCharCodec::createCodec( KEncoding C ) +{ + KCharCodec *Codec; + if( C == EBCDIC1047Encoding ) + Codec = KEBCDIC1047CharCodec::create(); + else if( C == ISO8859_1Encoding ) + Codec = KTextCharCodec::createCodec( "ISO 8859-1" ); + // LocalEncoding + else + Codec = 0; + + // ensure at least a codec + if( Codec == 0 ) + Codec = KTextCharCodec::createLocalCodec(); + + return Codec; +} diff --git a/khexedit/lib/codecs/kdecimalbytecodec.cpp b/khexedit/lib/codecs/kdecimalbytecodec.cpp new file mode 100644 index 0000000..9470382 --- /dev/null +++ b/khexedit/lib/codecs/kdecimalbytecodec.cpp @@ -0,0 +1,92 @@ +/*************************************************************************** + kdecimalbytecodec.cpp - description + ------------------- + begin : Mo Nov 29 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "kdecimalbytecodec.h" + +using namespace KHE; + + +void KDecimalByteCodec::encode( QString &Digits, unsigned int Pos, unsigned char Char ) const +{ + unsigned char C = Char / 100; + Digits.at(Pos++) = '0'+C; + Char -= C * 100; + C = Char / 10; + Digits.at(Pos++) = '0'+C; + Char -= C * 10; + Digits.at(Pos) = '0'+Char; +} + + +void KDecimalByteCodec::encodeShort( QString &Digits, unsigned int Pos, unsigned char Char ) const +{ + unsigned char C; + if( (C = Char / 100) ) + { + Digits.at(Pos++) = '0'+C; + Char -= C * 100; + } + if( (C = Char / 10) ) + { + Digits.at(Pos++) = '0'+C; + Char -= C * 10; + } + Digits.at(Pos) = '0'+Char; +} + + + +bool KDecimalByteCodec::isValidDigit( unsigned char Digit ) const +{ + return Digit >= '0' && Digit <= '9'; +} + +bool KDecimalByteCodec::turnToValue( unsigned char *Digit ) const +{ + if( isValidDigit(*Digit) ) + { + *Digit -= '0'; + return true; + } + return false; +} + + +bool KDecimalByteCodec::appendDigit( unsigned char *Byte, unsigned char Digit ) const +{ + if( turnToValue(&Digit) ) + { + unsigned char B = *Byte; + if( B < 26 ) + { + B *= 10; + if( Digit <= 255-B ) + { + B += Digit; + *Byte = B; + return true; + } + } + } + return false; +} + +void KDecimalByteCodec::removeLastDigit( unsigned char *Byte ) const +{ + *Byte /= 10; +} diff --git a/khexedit/lib/codecs/kdecimalbytecodec.h b/khexedit/lib/codecs/kdecimalbytecodec.h new file mode 100644 index 0000000..31f61d0 --- /dev/null +++ b/khexedit/lib/codecs/kdecimalbytecodec.h @@ -0,0 +1,59 @@ +/*************************************************************************** + kdecimalbytecodec.h - description + ------------------- + begin : Mo Nov 29 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KDECIMALBYTECODEC_H +#define KHE_KDECIMALBYTECODEC_H + +// lib specific +#include "kbytecodec.h" + +namespace KHE +{ + +/** class that is able to convert codings to and from binary + * + * the buffer will be always filled up to CodingWidth, if not using shortCodingFunction + * a closing '\0' will be always added + * + *@author Friedrich W. H. Kossebau + */ + +class KDecimalByteCodec : public KByteCodec +{ + public: // API to be implemented + /** */ + virtual unsigned int encodingWidth() const { return 3; } + /** */ + virtual unsigned char digitsFilledLimit() const { return 26; } + + /** encodes the Char and writes the result to */ + virtual void encode( QString &Digits, unsigned int Pos, const unsigned char Char ) const; + /** */ + virtual void encodeShort( QString &Digits, unsigned int Pos, const unsigned char Char ) const; + /** */ + virtual bool appendDigit( unsigned char *Byte, const unsigned char Digit ) const; + /** */ + virtual void removeLastDigit( unsigned char *Byte ) const; + /** */ + virtual bool isValidDigit( const unsigned char Digit ) const; + /** */ + virtual bool turnToValue( unsigned char *Digit ) const; +}; + +} + +#endif diff --git a/khexedit/lib/codecs/kebcdic1047charcodec.cpp b/khexedit/lib/codecs/kebcdic1047charcodec.cpp new file mode 100644 index 0000000..f26da37 --- /dev/null +++ b/khexedit/lib/codecs/kebcdic1047charcodec.cpp @@ -0,0 +1,124 @@ +/*************************************************************************** + kebcdic1047charcodec.cpp - description + ------------------- + begin : Sa Nov 27 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "kebcdic1047charcodec.h" + + +using namespace KHE; + +static Q_UINT16 UnicodeChars[256] = +{ + 0x0000, 0x0001, 0x0002, 0x0003, 0x009C, 0x0009, 0x0086, 0x007F, + 0x0097, 0x008D, 0x008E, 0x000B, 0x000C, 0x000D, 0x000E, 0x000F, + 0x0010, 0x0011, 0x0012, 0x0013, 0x009D, 0x0085, 0x0008, 0x0087, + 0x0018, 0x0019, 0x0092, 0x008F, 0x001C, 0x001D, 0x001E, 0x001F, + 0x0080, 0x0081, 0x0082, 0x0083, 0x0084, 0x000A, 0x0017, 0x001B, + 0x0088, 0x0089, 0x008A, 0x008B, 0x008C, 0x0005, 0x0006, 0x0007, + 0x0090, 0x0091, 0x0016, 0x0093, 0x0094, 0x0095, 0x0096, 0x0004, + 0x0098, 0x0099, 0x009A, 0x009B, 0x0014, 0x0015, 0x009E, 0x001A, + 0x0020, 0x00A0, 0x00E2, 0x00E4, 0x00E0, 0x00E1, 0x00E3, 0x00E5, + 0x00E7, 0x00F1, 0x00A2, 0x002E, 0x003C, 0x0028, 0x002B, 0x007C, + 0x0026, 0x00E9, 0x00EA, 0x00EB, 0x00E8, 0x00ED, 0x00EE, 0x00EF, + 0x00EC, 0x00DF, 0x0021, 0x0024, 0x002A, 0x0029, 0x003B, 0x005E, + 0x002D, 0x002F, 0x00C2, 0x00C4, 0x00C0, 0x00C1, 0x00C3, 0x00C5, + 0x00C7, 0x00D1, 0x00A6, 0x002C, 0x0025, 0x005F, 0x003E, 0x003F, + 0x00F8, 0x00C9, 0x00CA, 0x00CB, 0x00C8, 0x00CD, 0x00CE, 0x00CF, + 0x00CC, 0x0060, 0x003A, 0x0023, 0x0040, 0x0027, 0x003D, 0x0022, + 0x00D8, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067, + 0x0068, 0x0069, 0x00AB, 0x00BB, 0x00F0, 0x00FD, 0x00FE, 0x00B1, + 0x00B0, 0x006A, 0x006B, 0x006C, 0x006D, 0x006E, 0x006F, 0x0070, + 0x0071, 0x0072, 0x00AA, 0x00BA, 0x00E6, 0x00B8, 0x00C6, 0x00A4, + 0x00B5, 0x007E, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077, 0x0078, + 0x0079, 0x007A, 0x00A1, 0x00BF, 0x00D0, 0x005B, 0x00DE, 0x00AE, + 0x00AC, 0x00A3, 0x00A5, 0x00B7, 0x00A9, 0x00A7, 0x00B6, 0x00BC, + 0x00BD, 0x00BE, 0x00DD, 0x00A8, 0x00AF, 0x005D, 0x00B4, 0x00D7, + 0x007B, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047, + 0x0048, 0x0049, 0x00AD, 0x00F4, 0x00F6, 0x00F2, 0x00F3, 0x00F5, + 0x007D, 0x004A, 0x004B, 0x004C, 0x004D, 0x004E, 0x004F, 0x0050, + 0x0051, 0x0052, 0x00B9, 0x00FB, 0x00FC, 0x00F9, 0x00FA, 0x00FF, + 0x005C, 0x00F7, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057, 0x0058, + 0x0059, 0x005A, 0x00B2, 0x00D4, 0x00D6, 0x00D2, 0x00D3, 0x00D5, + 0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037, + 0x0038, 0x0039, 0x00B3, 0x00DB, 0x00DC, 0x00D9, 0x00DA, 0x009F +}; + +static unsigned char EBCDICChars[256] = +{ + 0x00, 0x01, 0x02, 0x03, 0x37, 0x2D, 0x2E, 0x2F, + 0x16, 0x05, 0x25, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + 0x10, 0x11, 0x12, 0x13, 0x3C, 0x3D, 0x32, 0x26, + 0x18, 0x19, 0x3F, 0x27, 0x1C, 0x1D, 0x1E, 0x1F, + 0x40, 0x5A, 0x7F, 0x7B, 0x5B, 0x6C, 0x50, 0x7D, + 0x4D, 0x5D, 0x5C, 0x4E, 0x6B, 0x60, 0x4B, 0x61, + 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, + 0xF8, 0xF9, 0x7A, 0x5E, 0x4C, 0x7E, 0x6E, 0x6F, + 0x7C, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, + 0xC8, 0xC9, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, + 0xD7, 0xD8, 0xD9, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, + 0xE7, 0xE8, 0xE9, 0xAD, 0xE0, 0xBD, 0x5F, 0x6D, + 0x79, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x88, 0x89, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, + 0x97, 0x98, 0x99, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, + 0xA7, 0xA8, 0xA9, 0xC0, 0x4F, 0xD0, 0xA1, 0x07, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x15, 0x06, 0x17, + 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x09, 0x0A, 0x1B, + 0x30, 0x31, 0x1A, 0x33, 0x34, 0x35, 0x36, 0x08, + 0x38, 0x39, 0x3A, 0x3B, 0x04, 0x14, 0x3E, 0xFF, + 0x41, 0xAA, 0x4A, 0xB1, 0x9F, 0xB2, 0x6A, 0xB5, + 0xBB, 0xB4, 0x9A, 0x8A, 0xB0, 0xCA, 0xAF, 0xBC, + 0x90, 0x8F, 0xEA, 0xFA, 0xBE, 0xA0, 0xB6, 0xB3, + 0x9D, 0xDA, 0x9B, 0x8B, 0xB7, 0xB8, 0xB9, 0xAB, + 0x64, 0x65, 0x62, 0x66, 0x63, 0x67, 0x9E, 0x68, + 0x74, 0x71, 0x72, 0x73, 0x78, 0x75, 0x76, 0x77, + 0xAC, 0x69, 0xED, 0xEE, 0xEB, 0xEF, 0xEC, 0xBF, + 0x80, 0xFD, 0xFE, 0xFB, 0xFC, 0xBA, 0xAE, 0x59, + 0x44, 0x45, 0x42, 0x46, 0x43, 0x47, 0x9C, 0x48, + 0x54, 0x51, 0x52, 0x53, 0x58, 0x55, 0x56, 0x57, + 0x8C, 0x49, 0xCD, 0xCE, 0xCB, 0xCF, 0xCC, 0xE1, + 0x70, 0xDD, 0xDE, 0xDB, 0xDC, 0x8D, 0x8E, 0xDF +}; + +static const char KEBCDIC1047CharCodecName[] = "EBCDIC 1047"; + + +bool KEBCDIC1047CharCodec::encode( char *D, const QChar &C ) const +{ + int I = C.unicode(); + // not in range? + if( 0x00FF < I ) + return false; + + *D = EBCDICChars[I]; + return true; +} + +KHEChar KEBCDIC1047CharCodec::decode( char Byte ) const +{ + return QChar(UnicodeChars[(unsigned char)Byte]); +} + +const QString& KEBCDIC1047CharCodec::name() const +{ + return codecName(); +} + +const QString& KEBCDIC1047CharCodec::codecName() +{ + static const QString Name( QString::fromLatin1(KEBCDIC1047CharCodecName) ); + return Name; +} diff --git a/khexedit/lib/codecs/kebcdic1047charcodec.h b/khexedit/lib/codecs/kebcdic1047charcodec.h new file mode 100644 index 0000000..7c30956 --- /dev/null +++ b/khexedit/lib/codecs/kebcdic1047charcodec.h @@ -0,0 +1,50 @@ +/*************************************************************************** + kebcdic1047charcodec.h - description + ------------------- + begin : Sa Nov 27 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KEBCDIC1047CHARCODEC_H +#define KHE_KEBCDIC1047CHARCODEC_H + + +#include "kcharcodec.h" + +namespace KHE +{ + +// +class KEBCDIC1047CharCodec : public KCharCodec +{ + protected: + KEBCDIC1047CharCodec(); + + public: // KCharCodec API + virtual KHEChar decode( char Byte ) const; + virtual bool encode( char *D, const QChar &C ) const; + virtual const QString& name() const; + + public: + static KEBCDIC1047CharCodec *create(); + static const QString& codecName(); +}; + + +inline KEBCDIC1047CharCodec::KEBCDIC1047CharCodec() {} + +inline KEBCDIC1047CharCodec *KEBCDIC1047CharCodec::create() { return new KEBCDIC1047CharCodec(); } + +} + +#endif diff --git a/khexedit/lib/codecs/khexadecimalbytecodec.cpp b/khexedit/lib/codecs/khexadecimalbytecodec.cpp new file mode 100644 index 0000000..7072464 --- /dev/null +++ b/khexedit/lib/codecs/khexadecimalbytecodec.cpp @@ -0,0 +1,113 @@ +/*************************************************************************** + khexadecimalbytecodec.cpp - description + ------------------- + begin : Mo Nov 29 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "khexadecimalbytecodec.h" + +using namespace KHE; + + +static const QChar BigDigit[16] = +{ '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F' }; +static const QChar SmallDigit[16] = +{ '0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f' }; + + +KHexadecimalByteCodec::KHexadecimalByteCodec( bool S ) : Digit( S?SmallDigit:BigDigit ) {} + +bool KHexadecimalByteCodec::setSmallDigits( bool S ) +{ + bool Change = ( S && Digit == BigDigit ); + Digit = S?SmallDigit:BigDigit; + return Change; +} + +bool KHexadecimalByteCodec::smallDigits() const { return Digit != BigDigit; } + + +void KHexadecimalByteCodec::encode( QString &Digits, unsigned int Pos, unsigned char Char ) const +{ + Digits.at(Pos++) = Digit[Char>>4]; + Digits.at(Pos) = Digit[Char&0x0F]; +} + +void KHexadecimalByteCodec::encodeShort( QString &Digits, unsigned int Pos, unsigned char Char ) const +{ + unsigned char C; + if( (C = (Char>>4)) ) + Digits.at(Pos++) = Digit[C]; + Digits.at(Pos) = Digit[Char&0x0F]; +} + + +static inline bool isValidBigDigit( unsigned char Digit ) +{ + return (Digit >= 'A' && Digit <= 'F'); +} + +static inline bool isValidSmallDigit( unsigned char Digit ) +{ + return (Digit >= 'a' && Digit <= 'f'); +} + +static inline bool isValidDecimalDigit( unsigned char Digit ) +{ + return Digit >= '0' && Digit <= '9'; +} + + +bool KHexadecimalByteCodec::isValidDigit( unsigned char Digit ) const +{ + return isValidDecimalDigit(Digit) || isValidBigDigit(Digit) || isValidSmallDigit(Digit); +} + +bool KHexadecimalByteCodec::turnToValue( unsigned char *Digit ) const +{ + if( isValidDecimalDigit(*Digit) ) + *Digit -= '0'; + else if( isValidBigDigit(*Digit) ) + *Digit -= 'A' - 10; + else if( isValidSmallDigit(*Digit) ) + *Digit -= 'a' - 10; + else + return false; + + return true; +} + +bool KHexadecimalByteCodec::appendDigit( unsigned char *Byte, unsigned char Digit ) const +{ + if( turnToValue(&Digit) ) + { + unsigned char B = *Byte; + if( B < 16 ) + { + B <<= 4; + B += Digit; + *Byte = B; + return true; + } + } + return false; +} + + + +void KHexadecimalByteCodec::removeLastDigit( unsigned char *Byte ) const +{ + *Byte >>= 4; +} diff --git a/khexedit/lib/codecs/khexadecimalbytecodec.h b/khexedit/lib/codecs/khexadecimalbytecodec.h new file mode 100644 index 0000000..9bb1969 --- /dev/null +++ b/khexedit/lib/codecs/khexadecimalbytecodec.h @@ -0,0 +1,69 @@ +/*************************************************************************** + khexadecimalbytecodec.h - description + ------------------- + begin : Mo Nov 29 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KHEXADECIMALBYTECODEC_H +#define KHE_KHEXADECIMALBYTECODEC_H + +// lib specific +#include "kbytecodec.h" + +namespace KHE +{ + +/** class that is able to convert codings to and from hexadecimal + * + * the buffer will be always filled up to CodingWidth, if not using shortCodingFunction + * a closing '\0' will be always added + * + *@author Friedrich W. H. Kossebau + */ + +class KHexadecimalByteCodec : public KByteCodec +{ + public: + KHexadecimalByteCodec( bool S = false ); + + public: + bool setSmallDigits( bool S ); + bool smallDigits() const; + + public: // API to be implemented + /** */ + virtual unsigned int encodingWidth() const { return 2; } + /** */ + virtual unsigned char digitsFilledLimit() const { return 16; } + + /** encodes the Char and writes the result to */ + virtual void encode( QString &Digits, unsigned int Pos, const unsigned char Char ) const; + /** */ + virtual void encodeShort( QString &Digits, unsigned int Pos, const unsigned char Char ) const; + /** */ + virtual bool appendDigit( unsigned char *Byte, const unsigned char Digit ) const; + /** */ + virtual void removeLastDigit( unsigned char *Byte ) const; + /** */ + virtual bool isValidDigit( const unsigned char Digit ) const; + /** */ + virtual bool turnToValue( unsigned char *Digit ) const; + + protected: + const QChar* Digit; +}; + +} + +#endif diff --git a/khexedit/lib/codecs/koctalbytecodec.cpp b/khexedit/lib/codecs/koctalbytecodec.cpp new file mode 100644 index 0000000..1167941 --- /dev/null +++ b/khexedit/lib/codecs/koctalbytecodec.cpp @@ -0,0 +1,80 @@ +/*************************************************************************** + koctalbytecodec.cpp - description + ------------------- + begin : Mo Nov 29 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "koctalbytecodec.h" + +using namespace KHE; + + +void KOctalByteCodec::encode( QString &Digits, unsigned int Pos, unsigned char Char ) const +{ + Digits.at(Pos++) = '0'+(Char>>6); + Digits.at(Pos++) = '0'+((Char>>3)&0x07); + Digits.at(Pos) = '0'+((Char) &0x07); +} + + +void KOctalByteCodec::encodeShort( QString &Digits, unsigned int Pos, unsigned char Char ) const +{ + unsigned char C; + if( (C = (Char>>6)&0x07) ) + Digits.at(Pos++) = '0'+C; + if( (C = (Char>>3)&0x07) ) + Digits.at(Pos++) = '0'+C; + Digits.at(Pos) = '0'+((Char)&0x07); +} + + +bool KOctalByteCodec::isValidDigit( unsigned char Digit ) const +{ + return Digit >= '0' && Digit <= '7'; +} + + +bool KOctalByteCodec::turnToValue( unsigned char *Digit ) const +{ + if( isValidDigit(*Digit) ) + { + *Digit -= '0'; + return true; + } + return false; +} + + +bool KOctalByteCodec::appendDigit( unsigned char *Byte, unsigned char Digit ) const +{ + if( turnToValue(&Digit) ) + { + unsigned char B = *Byte; + if( B < 64 ) + { + B <<= 3; + B += Digit; + *Byte = B; + return true; + } + } + return false; +} + + +void KOctalByteCodec::removeLastDigit( unsigned char *Byte ) const +{ + *Byte >>= 3; +} diff --git a/khexedit/lib/codecs/koctalbytecodec.h b/khexedit/lib/codecs/koctalbytecodec.h new file mode 100644 index 0000000..e05ca66 --- /dev/null +++ b/khexedit/lib/codecs/koctalbytecodec.h @@ -0,0 +1,59 @@ +/*************************************************************************** + koctalbytecodec.h - description + ------------------- + begin : Mo Nov 29 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KOCTALBYTECODEC_H +#define KHE_KOCTALBYTECODEC_H + +// lib specific +#include "kbytecodec.h" + +namespace KHE +{ + +/** class that is able to convert codings to and from binary + * + * the buffer will be always filled up to CodingWidth, if not using shortCodingFunction + * a closing '\0' will be always added + * + *@author Friedrich W. H. Kossebau + */ + +class KOctalByteCodec : public KByteCodec +{ + public: // API to be implemented + /** */ + virtual unsigned int encodingWidth() const { return 3; } + /** */ + virtual unsigned char digitsFilledLimit() const { return 64; } + + /** encodes the Char and writes the result to */ + virtual void encode( QString &Digits, unsigned int Pos, const unsigned char Char ) const; + /** */ + virtual void encodeShort( QString &Digits, unsigned int Pos, const unsigned char Char ) const; + /** */ + virtual bool appendDigit( unsigned char *Byte, const unsigned char Digit ) const; + /** */ + virtual void removeLastDigit( unsigned char *Byte ) const; + /** */ + virtual bool isValidDigit( const unsigned char Digit ) const; + /** */ + virtual bool turnToValue( unsigned char *Digit ) const; +}; + +} + +#endif diff --git a/khexedit/lib/codecs/ktextcharcodec.cpp b/khexedit/lib/codecs/ktextcharcodec.cpp new file mode 100644 index 0000000..613dedd --- /dev/null +++ b/khexedit/lib/codecs/ktextcharcodec.cpp @@ -0,0 +1,236 @@ +/*************************************************************************** + ktextcharcodec.cpp - description + ------------------- + begin : Sa Nov 27 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// qt specific +#include "qtextcodec.h" +// kde specific +#include <kglobal.h> +#include <klocale.h> +#include <kcharsets.h> +// lib specific +#include "ktextcharcodec.h" + + +using namespace KHE; + +static const char QTextCodecWhiteSpace = 63; + +static struct KEncodingNames { + KEncoding Encoding; + const char *Name; +} +const EncodingNames[] = { +{ ISO8859_1Encoding, "ISO 8859-1" }, +{ ISO8859_2Encoding, "ISO 8859-2" }, +{ ISO8859_3Encoding, "ISO 8859-3" }, +{ ISO8859_4Encoding, "ISO 8859-4" }, +{ ISO8859_5Encoding, "ISO 8859-5" }, +{ ISO8859_6Encoding, "ISO 8859-6" }, +{ ISO8859_7Encoding, "ISO 8859-7" }, +{ ISO8859_8Encoding, "ISO 8859-8" }, +{ ISO8859_8_IEncoding, "ISO 8859-8-I" }, +{ ISO8859_9Encoding, "ISO 8859-9" }, +{ ISO8859_11Encoding, "ISO 8859-11" }, +{ ISO8859_13Encoding, "ISO 8859-13" }, +{ ISO8859_15Encoding, "ISO 8859-15" }, +{ CP1250Encoding, "CP 1250" }, +{ CP1251Encoding, "CP 1251" }, +{ CP1252Encoding, "CP 1252" }, +{ CP1253Encoding, "CP 1253" }, +{ CP1254Encoding, "CP 1254" }, +{ CP1255Encoding, "CP 1255" }, +{ CP1256Encoding, "CP 1256" }, +{ CP1257Encoding, "CP 1257" }, +{ CP1258Encoding, "CP 1258" }, +{ IBM850Encoding, "IBM 850" }, +{ IBM866Encoding, "IBM 866" }, +{ KOI8_REncoding, "KOI8-R" }, +{ KOI8_UEncoding, "KOI8-U" } }; +//TODO: WS2 +static const unsigned int NoOfEncodings = 26; + +static bool is8Bit( QTextCodec *Codec ) +{ + bool Found = false; + for( unsigned int i=0; i<NoOfEncodings; ++i ) + { + if( qstrcmp(Codec->name(),EncodingNames[i].Name) == 0 ) + { + Found = true; + break; + } + } + return Found; +} + +static QTextCodec *createLatin1() +{ + return KGlobal::charsets()->codecForName( EncodingNames[0].Name ); +} + +/** heuristic seems to be doomed :( +static bool is8Bit( QTextCodec *Codec ) +{ + bool Result = true; + + // first test different for 0 + unsigned char c[4]; + c[0] = 0; + c[1] = c[2] = c[3] = 230; + QString S = Codec->toUnicode( (const char*)&c,4 ); + int Length = 1; + QCString CS = Codec->fromUnicode( S, Length ); + //kdDebug() << Codec->name() << " "<<Length << endl; + if( Length > 0 ) + Result = false; + // test if all chars survive the recoding + else + do + { + ++c[0]; + S = Codec->toUnicode( (const char*)&c,4 ); + Length = 1; + CS = Codec->fromUnicode( S, Length ); + //kdDebug() << Codec->name() << " "<<c[0]<<"->"<<CS[0]<<":"<<Length << endl; + if( Length != 1 || (CS[0] != (char)c[0] && CS[0] != QTextCodecWhiteSpace) ) + { + Result = false; + break; + } + } + while( c[0] < 255 ); + return Result; +} +const QStringList &KTextCharCodec::codecNames() +{ + // first call? + if( CodecNames.isEmpty() ) +{ + const QStringList &CharSets = KGlobal::charsets()->availableEncodingNames(); + + for( QStringList::ConstIterator it = CharSets.begin(); it != CharSets.end(); ++it ) +{ + bool Found = true; + QTextCodec* Codec = KGlobal::charsets()->codecForName( *it, Found ); + if( Found && is8Bit(Codec) ) + CodecNames.append( QString::fromLatin1(Codec->name()) ); +} +} + + return CodecNames; +} + +QString KTextCharCodec::nameOfEncoding( KEncoding C ) +{ + KTextCharCodec *Codec = 0; + + const char* N = 0; + for( unsigned int i=0; i<NoOfEncodings; ++i ) + { + if( EncodingNames[i].Encoding == C ) + { + N = EncodingNames[i].Name; + break; + } + } + + if( N != 0 ) + { + QString CodeName = QString::fromLatin1( N ); + } + return Codec; +} + */ + + +QStringList KTextCharCodec::CodecNames; + +KTextCharCodec *KTextCharCodec::createLocalCodec() +{ + QTextCodec *Codec = KGlobal::locale()->codecForEncoding(); + if( !is8Bit(Codec) ) + Codec = createLatin1(); + return new KTextCharCodec( Codec ); +} + + +KTextCharCodec *KTextCharCodec::createCodec( const QString &CodeName ) +{ + bool Ok; + QTextCodec *Codec = KGlobal::charsets()->codecForName( CodeName, Ok ); + if( Ok ) + Ok = is8Bit( Codec ); + return Ok ? new KTextCharCodec( Codec ) : 0; +} + + +const QStringList &KTextCharCodec::codecNames() +{ + // first call? + if( CodecNames.isEmpty() ) + { + for( unsigned int i=0; i<NoOfEncodings; ++i ) + { + bool Found = true; + QString Name = QString::fromLatin1( EncodingNames[i].Name ); + QTextCodec* Codec = KGlobal::charsets()->codecForName( Name, Found ); + if( Found ) + CodecNames.append( QString::fromLatin1(Codec->name()) ); + } + } + + return CodecNames; +} + + +KTextCharCodec::KTextCharCodec( QTextCodec *C ) + : Codec( C ), + Decoder( C->makeDecoder() ), + Encoder( C->makeEncoder() ) +{} + +KTextCharCodec::~KTextCharCodec() +{ + delete Decoder; + delete Encoder; +} + +bool KTextCharCodec::encode( char *D, const QChar &C ) const +{ + if( !Codec->canEncode(C) ) // TODO: do we really need the codec? + return false; + int dummy; + char T = Encoder->fromUnicode( C, dummy )[0]; + + *D = T; + return true; +} + + +KHEChar KTextCharCodec::decode( char Byte ) const +{ + QString S( Decoder->toUnicode(&Byte,1) ); + return KHEChar(S.at(0)); +} + + +const QString& KTextCharCodec::name() const +{ + if( Name.isNull() ) + Name = QString::fromLatin1( Codec->name() ); + return Name; +} diff --git a/khexedit/lib/codecs/ktextcharcodec.h b/khexedit/lib/codecs/ktextcharcodec.h new file mode 100644 index 0000000..683919c --- /dev/null +++ b/khexedit/lib/codecs/ktextcharcodec.h @@ -0,0 +1,66 @@ +/*************************************************************************** + ktextcharcodec.h - description + ------------------- + begin : Sa Nov 27 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KTEXTCHARCODEC_H +#define KHE_KTEXTCHARCODEC_H + + +#include "kcharcodec.h" + +class QTextCodec; +class QTextDecoder; +class QTextEncoder; + +namespace KHE +{ + +// used by all codecs with full char coping, i.e. there are no undefined chars +class KTextCharCodec : public KCharCodec +{ + public: + static KTextCharCodec *createCodec( const QString &CodeName ); + static KTextCharCodec *createCodec( KEncoding C ); + static KTextCharCodec *createLocalCodec(); + + static const QStringList &codecNames(); + + protected: + KTextCharCodec( QTextCodec *C ); + public: + virtual ~KTextCharCodec(); + + public: // KCharCodec API + virtual bool encode( char *D, const QChar &C ) const; + virtual KHEChar decode( char Byte ) const; + virtual const QString& name() const; + + + protected: + QTextCodec *Codec; + /** decodes the chars to unicode */ + QTextDecoder *Decoder; + /** encodes the chars from unicode */ + QTextEncoder *Encoder; + /** */ + mutable QString Name; + + static QStringList CodecNames; +}; + +} + +#endif diff --git a/khexedit/lib/controller/Makefile.am b/khexedit/lib/controller/Makefile.am new file mode 100644 index 0000000..5fd894b --- /dev/null +++ b/khexedit/lib/controller/Makefile.am @@ -0,0 +1,12 @@ +INCLUDES = -I$(srcdir)/.. $(all_includes) + +METASOURCES = AUTO + +# +noinst_LTLIBRARIES = libkcontroller.la +libkcontroller_la_SOURCES = kcontroller.cpp ktabcontroller.cpp knavigator.cpp \ + keditor.cpp kvalueeditor.cpp kchareditor.cpp + +# no public API +noinst_HEADERS = kcontroller.h ktabcontroller.h knavigator.h \ + keditor.h kvalueeditor.h kchareditor.h diff --git a/khexedit/lib/controller/kchareditor.cpp b/khexedit/lib/controller/kchareditor.cpp new file mode 100644 index 0000000..5b48fc6 --- /dev/null +++ b/khexedit/lib/controller/kchareditor.cpp @@ -0,0 +1,58 @@ +/*************************************************************************** + kchareditor.cpp - description + ------------------- + begin : Sa Dez 4 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// qt specific +#include <qevent.h> +// lib specific +#include "kcharcolumn.h" +#include "kcharcodec.h" +#include "khexedit.h" +#include "kchareditor.h" + + +using namespace KHE; + + +KCharEditor::KCharEditor( KCharColumn *CC, KBufferCursor *BC, KHexEdit *HE, KController *P ) + : KEditor( BC, HE, P ), + CharColumn( CC ) +{ +} + + +bool KCharEditor::handleKeyPress( QKeyEvent *KeyEvent ) +{ + bool KeyUsed = false; + // some input that should be inserted? + if( KeyEvent->text().length() > 0 + && !(KeyEvent->state()&( Qt::ControlButton | Qt::AltButton | Qt::MetaButton )) ) + { + QChar C = KeyEvent->text()[0]; + if( C.isPrint() ) + { + QByteArray D( 1 ); + if( CharColumn->codec()->encode(&D[0],C) ) + { + // clearUndoRedoInfo = false; + HexEdit->insert( D ); + KeyUsed = true; + } + } + } + + return KeyUsed ? true : KEditor::handleKeyPress(KeyEvent); +} diff --git a/khexedit/lib/controller/kchareditor.h b/khexedit/lib/controller/kchareditor.h new file mode 100644 index 0000000..74c3d8d --- /dev/null +++ b/khexedit/lib/controller/kchareditor.h @@ -0,0 +1,43 @@ +/*************************************************************************** + kchareditor.h - description + ------------------- + begin : Sa Dez 4 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KCHAREDITOR_H +#define KHE_KCHAREDITOR_H + +// lib specific +#include "keditor.h" + +namespace KHE +{ + +class KCharColumn; + +class KCharEditor : public KEditor +{ + public: + KCharEditor( KCharColumn *CC, KBufferCursor *BC, KHexEdit *HE, KController *P ); + + public: // KEditor API + virtual bool handleKeyPress( QKeyEvent *KeyEvent ); + + protected: + KCharColumn *CharColumn; +}; + +} + +#endif diff --git a/khexedit/lib/controller/kcontroller.cpp b/khexedit/lib/controller/kcontroller.cpp new file mode 100644 index 0000000..490da93 --- /dev/null +++ b/khexedit/lib/controller/kcontroller.cpp @@ -0,0 +1,34 @@ +/*************************************************************************** + kcontroller.cpp - description + ------------------- + begin : Sa Dez 4 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + + +// lib specific +#include "khexedit.h" +#include "kcontroller.h" + + +using namespace KHE; + +KController::KController( KHexEdit* HE, KController *P ) + : Parent( P ), HexEdit( HE ) +{ +} + +bool KController::handleKeyPress( QKeyEvent *KeyEvent ) +{ + return Parent ? Parent->handleKeyPress( KeyEvent ) : false; +} diff --git a/khexedit/lib/controller/kcontroller.h b/khexedit/lib/controller/kcontroller.h new file mode 100644 index 0000000..daeb0d5 --- /dev/null +++ b/khexedit/lib/controller/kcontroller.h @@ -0,0 +1,44 @@ +/*************************************************************************** + kcontroller.h - description + ------------------- + begin : Sa Dez 4 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KCONTROLLER_H +#define KHE_KCONTROLLER_H + + +class QKeyEvent; + +namespace KHE +{ + +class KHexEdit; + +class KController +{ + protected: + KController( KHexEdit *HE, KController *P ); + + public: // KController API + virtual bool handleKeyPress( QKeyEvent *KeyEvent ); + + protected: + KController *Parent; + KHexEdit *HexEdit; +}; + +} + +#endif diff --git a/khexedit/lib/controller/keditor.cpp b/khexedit/lib/controller/keditor.cpp new file mode 100644 index 0000000..7d4e92f --- /dev/null +++ b/khexedit/lib/controller/keditor.cpp @@ -0,0 +1,197 @@ +/*************************************************************************** + keditor.cpp - description + ------------------- + begin : Sa Dez 4 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + + +// lib specific +#include "kdatabuffer.h" +#include "kbufferranges.h" +#include "kbufferlayout.h" +#include "kbuffercursor.h" +#include "kwordbufferservice.h" +#include "khexedit.h" +#include "keditor.h" + + +using namespace KHE; + +KEditor::KEditor( KBufferCursor *BC, KHexEdit* HE, KController *P ) + : KController( HE, P ), + BufferCursor( BC ) +{ +} + + +bool KEditor::handleKeyPress( QKeyEvent *KeyEvent ) +{ + bool clearUndoRedoInfo = true; + bool ShiftPressed = KeyEvent->state() & Qt::ShiftButton; + bool ControlPressed = KeyEvent->state() & Qt::ControlButton; + bool AltPressed = KeyEvent->state() & Qt::AltButton; + + bool KeyUsed = true; + // we only care for cursor keys and the like, won't hardcode any other keys + // we also don't check whether the commands are allowed + // as the commands are also available as API so the check has to be done + // in each command anyway + switch( KeyEvent->key() ) + { + case Qt::Key_Delete: + if( ShiftPressed ) + HexEdit->cut(); + else if( HexEdit->BufferRanges->hasSelection() ) + HexEdit->removeSelectedData(); + else + { + doEditAction( ControlPressed ? WordDelete : CharDelete ); + clearUndoRedoInfo = false; + } + break; + + case Qt::Key_Insert: + if( ShiftPressed ) + HexEdit->paste(); + else if( ControlPressed ) + HexEdit->copy(); + else + HexEdit->setOverwriteMode( !HexEdit->OverWrite ); + break; + + case Qt::Key_Backspace: + if( AltPressed ) + { + if( ControlPressed ) + break; + else if( ShiftPressed ) + { +// HexEdit->redo(); + break; + } + else + { +// HexEdit->undo(); + break; + } + } + else if( HexEdit->BufferRanges->hasSelection() ) + { + HexEdit->removeSelectedData(); + break; + } + + doEditAction( ControlPressed ? WordBackspace : CharBackspace ); + clearUndoRedoInfo = false; + break; + case Qt::Key_F16: // "Copy" key on Sun keyboards + HexEdit->copy(); + break; + case Qt::Key_F18: // "Paste" key on Sun keyboards + HexEdit->paste(); + break; + case Qt::Key_F20: // "Cut" key on Sun keyboards + HexEdit->cut(); + break; + + default: + KeyUsed = false; + } + +// if( clearUndoRedoInfo ) +// clearUndoRedo(); +// changeIntervalTimer->start( 100, true ); + + return KeyUsed ? true : KController::handleKeyPress(KeyEvent); +} + + + +void KEditor::doEditAction( KEditAction Action ) +{ + KSection ChangedRange; + + HexEdit->pauseCursor( true ); + + switch( Action ) + { + case CharDelete: + if( !HexEdit->OverWrite ) + { + int Index = BufferCursor->realIndex(); + if( Index < HexEdit->BufferLayout->length() ) + { + ChangedRange = HexEdit->removeData( KSection(Index,1,false) ); + if( Index == HexEdit->BufferLayout->length() ) + BufferCursor->gotoEnd(); + } + } + break; + + case WordDelete: // kills data until the start of the next word + if( !HexEdit->OverWrite ) + { + int Index = BufferCursor->realIndex(); + if( Index < HexEdit->BufferLayout->length() ) + { + KWordBufferService WBS( HexEdit->DataBuffer, HexEdit->Codec ); + int End = WBS.indexOfBeforeNextWordStart( Index ); + ChangedRange = HexEdit->removeData( KSection(Index,End) ); + if( Index == HexEdit->BufferLayout->length() ) + BufferCursor->gotoEnd(); + } + } + break; + + case CharBackspace: + if( HexEdit->OverWrite ) + BufferCursor->gotoPreviousByte(); + else + { + int DeleteIndex = BufferCursor->realIndex() - 1; + if( DeleteIndex >= 0 ) + { + ChangedRange = HexEdit->removeData( KSection(DeleteIndex,1,false) ); + if( DeleteIndex == HexEdit->BufferLayout->length() ) + BufferCursor->gotoEnd(); + else + BufferCursor->gotoPreviousByte(); + } + } + break; + case WordBackspace: + { + int LeftIndex = BufferCursor->realIndex() - 1; + if( LeftIndex >= 0 ) + { + KWordBufferService WBS( HexEdit->DataBuffer, HexEdit->Codec ); + int WordStart = WBS.indexOfPreviousWordStart( LeftIndex ); + if( !HexEdit->OverWrite ) + ChangedRange = HexEdit->removeData( KSection(WordStart,LeftIndex) ); + if( WordStart == HexEdit->BufferLayout->length() ) + BufferCursor->gotoEnd(); + else + BufferCursor->gotoIndex(WordStart); + } + } + } + + HexEdit->repaintChanged(); + HexEdit->ensureCursorVisible(); + + HexEdit->unpauseCursor(); + + emit HexEdit->cursorPositionChanged( BufferCursor->index() ); + if( ChangedRange.isValid() ) emit HexEdit->bufferChanged( ChangedRange.start(), ChangedRange.end() ); +} diff --git a/khexedit/lib/controller/keditor.h b/khexedit/lib/controller/keditor.h new file mode 100644 index 0000000..dc2b0fd --- /dev/null +++ b/khexedit/lib/controller/keditor.h @@ -0,0 +1,52 @@ +/*************************************************************************** + keditor.h - description + ------------------- + begin : Sa Dez 4 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KEDITOR_H +#define KHE_KEDITOR_H + + +// lib specific +#include "kcontroller.h" + + +namespace KHE +{ + +class KBufferCursor; + +class KEditor : public KController +{ + protected: + enum KEditAction { CharDelete, WordDelete, CharBackspace, WordBackspace }; + + protected: + KEditor( KBufferCursor *BC, KHexEdit *HE, KController *P ); + + public: // API + virtual bool handleKeyPress( QKeyEvent *KeyEvent ); + + protected: + /** executes keyboard Action \a Action. This is normally called by a key event handler. */ + void doEditAction( KEditAction Action ); + + protected: + KBufferCursor *BufferCursor; +}; + +} + +#endif diff --git a/khexedit/lib/controller/knavigator.cpp b/khexedit/lib/controller/knavigator.cpp new file mode 100644 index 0000000..51c8048 --- /dev/null +++ b/khexedit/lib/controller/knavigator.cpp @@ -0,0 +1,142 @@ +/*************************************************************************** + knavigator.cpp - description + ------------------- + begin : Sa Dez 4 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + + +// qt specific +#include <qevent.h> +// lib specific +#include "kdatabuffer.h" +#include "kbufferranges.h" +#include "kbuffercursor.h" +#include "kwordbufferservice.h" +#include "khexedit.h" +#include "knavigator.h" + + +using namespace KHE; + +KNavigator::KNavigator( KHexEdit* HE, KController *P ) + : KController( HE, P ) +{ +} + +bool KNavigator::handleKeyPress( QKeyEvent *KeyEvent ) +{ + bool KeyUsed = true; + + //bool clearUndoRedoInfo = true; + bool ShiftPressed = KeyEvent->state() & Qt::ShiftButton; + bool ControlPressed = KeyEvent->state() & Qt::ControlButton; + //bool AltPressed = KeyEvent->state() & AltButton; + + // we only care for cursor keys and the like, won't hardcode any other keys + // we also don't check whether the commands are allowed + // as the commands are also available as API so the check has to be done + // in each command anyway + switch( KeyEvent->key() ) + { + case Qt::Key_Left: + moveCursor( ControlPressed ? MoveWordBackward : MoveBackward, ShiftPressed ); + break; + case Qt::Key_Right: + moveCursor( ControlPressed ? MoveWordForward : MoveForward, ShiftPressed ); + break; + case Qt::Key_Up: + moveCursor( ControlPressed ? MovePgUp : MoveUp, ShiftPressed ); + break; + case Qt::Key_Down: + moveCursor( ControlPressed ? MovePgDown : MoveDown, ShiftPressed ); + break; + case Qt::Key_Home: + moveCursor( ControlPressed ? MoveHome : MoveLineStart, ShiftPressed ); + break; + case Qt::Key_End: + moveCursor( ControlPressed ? MoveEnd : MoveLineEnd, ShiftPressed ); + break; + case Qt::Key_Prior: + moveCursor( MovePgUp, ShiftPressed ); + break; + case Qt::Key_Next: + moveCursor( MovePgDown, ShiftPressed ); + break; + + default: + KeyUsed = false; + } + + return KeyUsed ? true : KController::handleKeyPress(KeyEvent); +} + + +void KNavigator::moveCursor( KMoveAction Action, bool Select ) +{ + HexEdit->pauseCursor( true ); + + KBufferCursor *BufferCursor = HexEdit->BufferCursor; + KBufferRanges *BufferRanges = HexEdit->BufferRanges; + + if( Select ) + { + if( !BufferRanges->selectionStarted() ) + BufferRanges->setSelectionStart( BufferCursor->realIndex() ); + } + else + BufferRanges->removeSelection(); + + HexEdit->resetInputContext(); + switch( Action ) + { + case MoveBackward: BufferCursor->gotoPreviousByte(); break; + case MoveWordBackward: { + KWordBufferService WBS( HexEdit->DataBuffer, HexEdit->Codec ); + int NewIndex = WBS.indexOfPreviousWordStart( BufferCursor->realIndex() ); + BufferCursor->gotoIndex( NewIndex ); + } + break; + case MoveForward: BufferCursor->gotoNextByte(); break; + case MoveWordForward: { + KWordBufferService WBS( HexEdit->DataBuffer, HexEdit->Codec ); + int NewIndex = WBS.indexOfNextWordStart( BufferCursor->realIndex() ); + BufferCursor->gotoCIndex( NewIndex ); + } + break; + case MoveUp: BufferCursor->gotoUp(); break; + case MovePgUp: BufferCursor->gotoPageUp(); break; + case MoveDown: BufferCursor->gotoDown(); break; + case MovePgDown: BufferCursor->gotoPageDown(); break; + case MoveLineStart: BufferCursor->gotoLineStart(); break; + case MoveHome: BufferCursor->gotoStart(); break; + case MoveLineEnd: BufferCursor->gotoLineEnd(); break; + case MoveEnd: BufferCursor->gotoEnd(); break; + } + + if( Select ) + BufferRanges->setSelectionEnd( BufferCursor->realIndex() ); + + HexEdit->repaintChanged(); + HexEdit->ensureCursorVisible(); + + HexEdit->unpauseCursor(); + + if( BufferRanges->isModified() ) + { + if( !HexEdit->isOverwriteMode() ) emit HexEdit->cutAvailable( BufferRanges->hasSelection() ); + emit HexEdit->copyAvailable( BufferRanges->hasSelection() ); + KSection Selection = BufferRanges->selection(); + emit HexEdit->selectionChanged( Selection.start(), Selection.end() ); + } +} diff --git a/khexedit/lib/controller/knavigator.h b/khexedit/lib/controller/knavigator.h new file mode 100644 index 0000000..4615419 --- /dev/null +++ b/khexedit/lib/controller/knavigator.h @@ -0,0 +1,46 @@ +/*************************************************************************** + knavigator.h - description + ------------------- + begin : Sa Dez 4 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KNAVIGATOR_H +#define KHE_KNAVIGATOR_H + +// lib specific +#include "kcontroller.h" + +namespace KHE +{ + +class KNavigator : public KController +{ + protected: + enum KMoveAction { MoveBackward, MoveWordBackward, MoveForward, MoveWordForward, + MoveUp, MovePgUp, MoveDown, MovePgDown, + MoveLineStart, MoveHome, MoveLineEnd, MoveEnd }; + public: + KNavigator( KHexEdit *HE, KController *P ); + + public: // KEditor API + virtual bool handleKeyPress( QKeyEvent *KeyEvent ); + + protected: + /** moves the cursor according to the action, handles all drawing */ + void moveCursor( KMoveAction Action, bool Select ); +}; + +} + +#endif diff --git a/khexedit/lib/controller/ktabcontroller.cpp b/khexedit/lib/controller/ktabcontroller.cpp new file mode 100644 index 0000000..76c3051 --- /dev/null +++ b/khexedit/lib/controller/ktabcontroller.cpp @@ -0,0 +1,70 @@ +/*************************************************************************** + ktabcontroller.cpp - description + ------------------- + begin : So Dez 5 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// qt specific +#include <qevent.h> +// lib specific +#include "kvaluecolumn.h" +#include "kcharcolumn.h" +#include "khexedit.h" +#include "ktabcontroller.h" + + +using namespace KHE; + +KTabController::KTabController( KHexEdit* HE, KController *P ) + : KController( HE, P ), + TabChangesFocus( false ) +{ +} + + +bool KTabController::handleKeyPress( QKeyEvent *KeyEvent ) +{ + bool KeyUsed = false; + + bool ShiftPressed = KeyEvent->state() & Qt::ShiftButton; + + if( KeyEvent->key() == Qt::Key_Tab ) + { + // are we in the char column? + if( HexEdit->cursorColumn() == KHexEdit::CharColumnId ) + { + // in last column we care about tab changes focus + if( HexEdit->ValueColumn->isVisible() && (!TabChangesFocus || ShiftPressed) ) + { + HexEdit->setCursorColumn( KHexEdit::ValueColumnId ); + KeyUsed = true; + } + } + // value column then + else + { + if( HexEdit->CharColumn->isVisible() ) + { + // in last column we care about tab changes focus + if( HexEdit->CharColumn->isVisible() && (!TabChangesFocus || !ShiftPressed) ) + { + HexEdit->setCursorColumn( KHexEdit::CharColumnId ); + KeyUsed = true; + } + } + } + } + + return KeyUsed ? true : KController::handleKeyPress(KeyEvent); +} diff --git a/khexedit/lib/controller/ktabcontroller.h b/khexedit/lib/controller/ktabcontroller.h new file mode 100644 index 0000000..e1898b4 --- /dev/null +++ b/khexedit/lib/controller/ktabcontroller.h @@ -0,0 +1,52 @@ +/*************************************************************************** + ktabcontroller.h - description + ------------------- + begin : So Dez 5 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KTABCONTROLLER_H +#define KHE_KTABCONTROLLER_H + + +// lib specific +#include "kcontroller.h" + + +namespace KHE +{ + +class KTabController : public KController +{ + public: + KTabController( KHexEdit *HE, KController *P ); + + public: // API + virtual bool handleKeyPress( QKeyEvent *KeyEvent ); + + public: + bool tabChangesFocus() const; + void setTabChangesFocus( bool TCF ); + + protected: + /** flag if tab key should be ignored */ + bool TabChangesFocus:1; +}; + + +inline bool KTabController::tabChangesFocus() const { return TabChangesFocus; } +inline void KTabController::setTabChangesFocus( bool TCF ) { TabChangesFocus = TCF; } + +} + +#endif diff --git a/khexedit/lib/controller/kvalueeditor.cpp b/khexedit/lib/controller/kvalueeditor.cpp new file mode 100644 index 0000000..ebfb589 --- /dev/null +++ b/khexedit/lib/controller/kvalueeditor.cpp @@ -0,0 +1,226 @@ +/*************************************************************************** + kvalueeditor.cpp - description + ------------------- + begin : Sa Dez 4 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// qt specific +#include <qevent.h> +// lib specific +#include "kvaluecolumn.h" +#include "kbufferranges.h" +#include "kbuffercursor.h" +#include "khexedit.h" +#include "kvalueeditor.h" + + +using namespace KHE; + +KValueEditor::KValueEditor( KValueColumn *VC, KBufferCursor *BC, KHexEdit* HE, KController *P ) + : KEditor( BC, HE, P ), + ValueColumn( VC ), + InEditMode( false ), + EditModeByInsert( false ) +{ +} + + +bool KValueEditor::handleKeyPress( QKeyEvent *KeyEvent ) +{ + bool KeyUsed = true; + + // TODO: for now we don't touch it if there are selections + if( !HexEdit->BufferRanges->hasSelection() ) + { + // + switch( KeyEvent->key() ) + { + case Qt::Key_Plus: + doValueEditAction( IncValue ); + break; + case Qt::Key_Minus: + doValueEditAction( DecValue ); + break; + case Qt::Key_Space: + if( !InEditMode ) + { + KeyUsed = false; + break; + } + case Qt::Key_Enter: + case Qt::Key_Return: + doValueEditAction( InEditMode?LeaveValue:EnterValue ); + break; + case Qt::Key_Escape: + if( InEditMode ) + doValueEditAction( CancelValue ); + else + KeyUsed = false; + break; + case Qt::Key_Backspace: + if( InEditMode ) + doValueEditAction( ValueBackspace ); + else + KeyUsed = false; + break; + default: + // is plain char? + if( KeyEvent->text().length() > 0 + && ( !(KeyEvent->state()&( Qt::ControlButton | Qt::AltButton | Qt::MetaButton )) ) ) + { + QChar C = KeyEvent->text()[0]; + // no usable char? + if( !C.isLetterOrNumber() ) + { + KeyUsed = false; + break; + } + int Input = C.latin1(); + + if( InEditMode ) + doValueEditAction( ValueAppend, Input ); + else + { + unsigned char InputValue = 0; + const KByteCodec *ByteCodec = ValueColumn->byteCodec(); + // valid digit? + if( ByteCodec->appendDigit(&InputValue,Input) ) + { + if( HexEdit->OverWrite ) + doValueEditAction( ValueEdit, InputValue ); + else + { + int Index = BufferCursor->realIndex(); + if( HexEdit->DataBuffer->insert(Index,(char*)&InputValue,1) > 0 ) + { + HexEdit->pauseCursor(); + HexEdit->updateLength(); + + InEditMode = true; + EditModeByInsert = true; + OldValue = EditValue = InputValue; + ByteCodec->encode( ByteBuffer, 0, EditValue ); + + BufferCursor->gotoRealIndex(); + KSection ChangedRange( Index,HexEdit->DataBuffer->size()-1 ); + HexEdit->BufferRanges->addChangedRange( ChangedRange ); + HexEdit->repaintChanged(); + HexEdit->ensureCursorVisible(); + HexEdit->unpauseCursor(); + HexEdit->updateCursor(); + emit HexEdit->bufferChanged( ChangedRange.start(), ChangedRange.end() ); + } + } + } + } + } + else + KeyUsed = false; + } + } + else + KeyUsed = false; + + return KeyUsed ? true : KEditor::handleKeyPress(KeyEvent); +} + + +void KValueEditor::doValueEditAction( KValueEditAction Action, int Input ) +{ + // we are not yet in edit mode? + if( !InEditMode ) + { + int ValidIndex = BufferCursor->validIndex(); + // no valid cursor position? + if( ValidIndex == -1 || (!HexEdit->OverWrite && Input == -1) || BufferCursor->isBehind() ) + return; + + InEditMode = true; + EditModeByInsert = false; // default, to be overwritten if so + + // save old value + OldValue = EditValue = (unsigned char)HexEdit->DataBuffer->datum(ValidIndex); + } + + const KByteCodec *ByteCodec = ValueColumn->byteCodec(); + // + unsigned char NewValue = EditValue; + bool StayInEditMode = true; + bool MoveToNext = false; + + switch( Action ) + { + case ValueEdit: + NewValue = Input; + EditValue = NewValue^255; // force update + EditModeByInsert = true; + break; + case ValueBackspace: + if( NewValue > 0 ) + ByteCodec->removeLastDigit( &NewValue ); + break; + case EnterValue: + EditValue ^= 255; // force update + break; + case IncValue: + if( NewValue < 255 ) + ++NewValue; + break; + case DecValue: + if( NewValue > 0 ) + --NewValue; + break; + case ValueAppend: + if( ByteCodec->appendDigit(&NewValue,Input) ) + if( EditModeByInsert && NewValue >= ByteCodec->digitsFilledLimit() ) + { + StayInEditMode = false; + MoveToNext = true; + } + break; + case LeaveValue: + StayInEditMode = false; + MoveToNext = EditModeByInsert; + break; + case CancelValue: + NewValue = OldValue; + StayInEditMode = false; + break; + } + + bool Changed = (NewValue != EditValue); + int Index = BufferCursor->index(); + if( Changed ) + { + // sync value + EditValue = NewValue; + ByteCodec->encode( ByteBuffer, 0, EditValue ); + + HexEdit->DataBuffer->replace( Index, 1, (char*)&EditValue, 1 ); + } + + HexEdit->updateCursor(); + + if( !StayInEditMode ) + { + HexEdit->pauseCursor(); + InEditMode = false; + if( MoveToNext ) + BufferCursor->gotoNextByte(); + HexEdit->unpauseCursor(); + } + + if( Changed ) + if( Action != EnterValue ) emit HexEdit->bufferChanged( Index, Index ); +} diff --git a/khexedit/lib/controller/kvalueeditor.h b/khexedit/lib/controller/kvalueeditor.h new file mode 100644 index 0000000..496bcde --- /dev/null +++ b/khexedit/lib/controller/kvalueeditor.h @@ -0,0 +1,75 @@ +/*************************************************************************** + kvalueeditor.h - description + ------------------- + begin : Sa Dez 4 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KVALUEEDITOR_H +#define KHE_KVALUEEDITOR_H + + +// lib specific +#include "keditor.h" + +namespace KHE +{ + +class KValueColumn; + + +class KValueEditor: public KEditor +{ + protected: + enum KValueEditAction + { EnterValue, IncValue, DecValue, ValueAppend, ValueEdit, LeaveValue, CancelValue, ValueBackspace }; + + public: + KValueEditor( KValueColumn *VC, KBufferCursor *BC, KHexEdit *HE, KController *P ); + virtual ~KValueEditor(); + + public: // KEditor API + virtual bool handleKeyPress( QKeyEvent *KeyEvent ); + + public: + void reset(); + + public: + bool isInEditMode() const; + + protected: + /** executes keyboard Action \a Action. This is normally called by a key event handler. */ + void doValueEditAction( KValueEditAction Action, int Input = -1 ); + + public://protected: + KValueColumn *ValueColumn; + /** flag whether we are in editing mode */ + bool InEditMode:1; + /** flag whether byte edit mode was reached by inserting */ + bool EditModeByInsert:1; + /** */ + unsigned char EditValue; + /** stores the old byte value */ + unsigned char OldValue; + /** buffer with the */ + QString ByteBuffer; +}; + +inline KValueEditor::~KValueEditor() {} + +inline bool KValueEditor::isInEditMode() const { return InEditMode; } +inline void KValueEditor::reset() { InEditMode = false; } + +} + +#endif diff --git a/khexedit/lib/helper.h b/khexedit/lib/helper.h new file mode 100644 index 0000000..600ac5b --- /dev/null +++ b/khexedit/lib/helper.h @@ -0,0 +1,31 @@ +/*************************************************************************** + helper.h - description + ------------------- + begin : Fri Oct 03 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + +#ifndef KHEXEDIT_HELPER +#define KHEXEDIT_HELPER + +// qt specific +#include <qcolor.h> +// lib specific +#include <khechar.h> + +// temporary solution until syntax highlighting is implemented +static inline QColor colorForChar( const KHE::KHEChar Byte ) +{ + return Byte.isUndefined() ? Qt::yellow : Byte.isPunct() ? Qt::red : Byte.isPrint() ? Qt::black : Qt::blue; +} + +#endif diff --git a/khexedit/lib/kadds.h b/khexedit/lib/kadds.h new file mode 100644 index 0000000..77c86f5 --- /dev/null +++ b/khexedit/lib/kadds.h @@ -0,0 +1,36 @@ +/*************************************************************************** + kadds.h - description + ------------------- + begin : Die Mai 20 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KADDS_H +#define KHE_KADDS_H + +namespace KHE +{ +// some possibly usefull aditions to KDE + +// these are to emphasize that measuring unit is pixel and which direction +typedef int KPixelX; +typedef int KPixelY; + +class KSection; + +typedef KSection KPixelXs; +typedef KSection KPixelYs; + +} + +#endif diff --git a/khexedit/lib/kbigbuffer.cpp b/khexedit/lib/kbigbuffer.cpp new file mode 100644 index 0000000..8505ef7 --- /dev/null +++ b/khexedit/lib/kbigbuffer.cpp @@ -0,0 +1,216 @@ +/*************************************************************************** + kbigbuffer.cpp - description + ------------------- + begin : Mit Jun 02 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// c specific +#include <stdlib.h> +// lib specific +#include "kbigbuffer.h" + +using namespace KHE; + +KBigBuffer::KBigBuffer( int NP, int PS ) + : NoOfUsedPages( NP ), + NoOfFreePages( NP ), + PageSize( PS ), + FirstPage( -1 ), + LastPage( -1 ), + Size( 0 ) +{ + IsOpen = false; + +// if( !filename.empty() ) +// open(filename); +} + + +KBigBuffer::~KBigBuffer() +{ + if( File.isOpen() ) + close(); +} + + + +bool KBigBuffer::prepareRange( KSection /*Range*/ ) const +{ + return true; +} + +const char *KBigBuffer::dataSet( KSection /*Section*/ ) const +{ + return 0; +} + + +char KBigBuffer::datum( unsigned int DatumOffset ) const +{ +// std::cout << "reading datum " << DatumOffset << std::endl; + int OffsetInPage = DatumOffset - OffsetOfActualPage; + // there shouldn't be any need to check l + if( OffsetInPage >= 0 && OffsetInPage < (int)PageSize ) + return ActualPage[OffsetInPage]; + + // load the page + unsigned int PageIndex = DatumOffset / PageSize; + ensurePageLoaded( PageIndex ); + return ActualPage[DatumOffset-OffsetOfActualPage]; +} + + + + +int KBigBuffer::insert( int /*Pos*/, const char*, int /*Length*/ ) +{ + return 0; +} + +int KBigBuffer::remove( KSection /*Section*/ ) +{ + return 0; +} + +unsigned int KBigBuffer::replace( KSection /*Section*/, const char*, unsigned int /*Length*/ ) +{ + return 0; +} + +int KBigBuffer::fill( char /*FillChar*/, int /*Length*/, unsigned int /*Pos*/ ) +{ + return 0; +} + + +int KBigBuffer::move( int /*DestPos*/, KSection /*SourceSection*/ ) { return 0; } +//int KBigBuffer::find( const char*, int /*Length*/, int /*Pos*/ ) const { return 0; } +int KBigBuffer::find( const char*/*KeyData*/, int /*Length*/, KSection /*Section*/ ) const { return 0; } + +int KBigBuffer::rfind( const char*, int /*Length*/, int /*Pos*/ ) const { return 0; } + + + +bool KBigBuffer::open( const QString& FileName ) +{ + // clear old data + if( isOpen() && !close() ) // only occurs if close somehow fails. + return false; + + File.setName( FileName ); + if( !File.open(IO_ReadOnly|IO_Raw) ) + return false; + +// std::cout << "loading file " << FileName << std::endl; + + int FileSize = File.size(); + Size = FileSize; + + // calculate necessary number of pages + int NoOfPages = FileSize/PageSize + 1; + + // initialize Page pointers + Data.resize( NoOfPages ); + for( KPageOfChar::iterator D=Data.begin(); D!=Data.end(); ++D ) + *D = 0; + + FirstPage = LastPage = 0; + + return ensurePageLoaded( 0 ); +} + + +bool KBigBuffer::close() +{ + if( !isOpen() ) + return false; + + File.close(); + + if( File.status() == IO_UnspecifiedError ) + return false; + +// std::cout << "closing file " << std::endl; + + // free pages + for( KPageOfChar::iterator D=Data.begin(); D!=Data.end(); ++D ) + delete [] *D; + + FirstPage = LastPage = -1; + NoOfFreePages = NoOfUsedPages; + + return true; +} + + +bool KBigBuffer::ensurePageLoaded( unsigned int PageIndex ) const +{ + if( !isOpen() ) + return false; + // page loaded? + if( Data[PageIndex] != 0 ) + { + ActualPage = Data[PageIndex]; + OffsetOfActualPage = PageIndex * PageSize; + return true; + } + + // no page available? + if( NoOfFreePages < 1 ) + { + // free the page which is the furthest away from the page we are loading + if( abs(FirstPage-PageIndex) > abs(LastPage-PageIndex) ) + while( !freePage(FirstPage++) ); + else + while( !freePage(LastPage--) ); + } + +// std::cout << "loading page " << PageIndex << std::endl; + // create Page + Data[PageIndex] = new char[PageSize]; + --NoOfFreePages; + + // jump to position and read the page's data in + bool Success = File.at( (unsigned long)(PageIndex*PageSize) ); + if( Success ) + Success = File.readBlock( Data[PageIndex], PageSize ) > 0; + + if( Success ) + { + // correct bounds + if( (int)PageIndex < FirstPage ) + FirstPage = PageIndex; + + if( (int)PageIndex > LastPage ) + LastPage = PageIndex; + + ActualPage = Data[PageIndex]; + OffsetOfActualPage = PageIndex * PageSize; + } + + return Success; +} + + +bool KBigBuffer::freePage( unsigned int PageIndex ) const +{ + // check range and if is loaded at all + if( (unsigned int)PageIndex >= Data.size() || !Data[PageIndex] ) + return false; +// std::cout << "freeing page " << PageIndex << std::endl; + delete [] Data[PageIndex]; + Data[PageIndex] = 0; + ++NoOfFreePages; + return true; +} diff --git a/khexedit/lib/kbigbuffer.h b/khexedit/lib/kbigbuffer.h new file mode 100644 index 0000000..138e64b --- /dev/null +++ b/khexedit/lib/kbigbuffer.h @@ -0,0 +1,119 @@ +/*************************************************************************** + kbigbuffer.h - description + ------------------- + begin : Mit Jun 02 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBIGBUFFER_H +#define KHE_KBIGBUFFER_H + +// qt specific +#include <qvaluevector.h> +#include <qfile.h> +// lib specific +#include "kdatabuffer.h" +#include "khexedit_export.h" + +namespace KHE { + +/** base class for all Data buffers that are used to display + * TODO: think about a way to inform KHexEdit that there has been + * a change in the buffer outside. what kind of changes are possible? + *@author Friedrich W. H. Kossebau + */ + +class KHEXEDIT_EXPORT KBigBuffer : public KDataBuffer +{ + typedef QValueVector<char *> KPageOfChar; + + public: + /** default is only 50*4k = 200k memory image */ + KBigBuffer( int NP = 50, int PS = 4096 ); + virtual ~KBigBuffer(); + + public: // KDataBuffer API + virtual bool prepareRange( KSection Range ) const; + virtual const char *dataSet( KSection S ) const; + virtual char datum( unsigned int Offset ) const; + virtual int size() const; + virtual bool isReadOnly() const; + virtual bool isModified() const; + + virtual int insert( int Pos, const char*, int Length ); + virtual int remove( KSection S ); + virtual unsigned int replace( KSection S, const char*, unsigned int InputLength ); + virtual int move( int DestPos, KSection SourceSection ); + virtual int fill( char FillChar, int Length = -1, unsigned int Pos = 0 ); + virtual void setDatum( unsigned int Offset, const char Char ); + + virtual void setModified( bool M = true ); + + //virtual int find( const char*, int Length, int Pos = 0 ) const; + virtual int find( const char*KeyData, int Length, KSection Section ) const; + virtual int rfind( const char*, int Length, int Pos = -1 ) const; + +/* virtual int find( const QString &expr, bool cs, bool wo, bool forward = true, int *index = 0 ); */ + + public: + void setReadOnly( bool RO = true ); + bool isOpen() const; + bool open (const QString& filename ); + bool close(); + + protected: + bool ensurePageLoaded( unsigned int PageIndex ) const; + bool freePage( unsigned int PageIndex ) const; + + + protected: + /** */ + mutable QFile File; + /** */ + bool ReadOnly:1; + bool IsOpen:1; + bool AtEOF:1; + /** maximum number of pages which could be currently loaded */ + unsigned int NoOfUsedPages; + /** number of actually not used pages (in terms of NoOfUsedPages) */ + mutable int NoOfFreePages; + /** number of bytes in a page */ + unsigned int PageSize; + /** first currently loaded page */ + mutable int FirstPage; + /** last currently loaded page */ + mutable int LastPage; + /** */ + mutable KPageOfChar Data; + /** */ + unsigned int Size; + + /** current offset */ + mutable unsigned int OffsetOfActualPage; + /** points to the actual page */ + mutable char* ActualPage; +}; + +inline int KBigBuffer::size() const { return Size; } +inline bool KBigBuffer::isReadOnly() const { return ReadOnly; } +inline bool KBigBuffer::isModified() const { return false; } +inline void KBigBuffer::setReadOnly( bool RO ) { ReadOnly = RO; } +inline void KBigBuffer::setModified( bool ) {} + +inline void KBigBuffer::setDatum( unsigned int, const char ) {} + +inline bool KBigBuffer::isOpen() const { return File.isOpen(); } + +} + +#endif diff --git a/khexedit/lib/kbordercoltextexport.cpp b/khexedit/lib/kbordercoltextexport.cpp new file mode 100644 index 0000000..d46490f --- /dev/null +++ b/khexedit/lib/kbordercoltextexport.cpp @@ -0,0 +1,47 @@ +/*************************************************************************** + kbordercoltextexport.cpp - description + ------------------- + begin : Sam Aug 30 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// qt specific +#include <qstring.h> +// lib specific +#include "kbordercoltextexport.h" + + +using namespace KHE; + +static const uint BorderColumnTEWidth = 3; + + +int KBorderColTextExport::charsPerLine() const +{ + return BorderColumnTEWidth; +} + +void KBorderColTextExport::printFirstLine( QString &T, int /*Line*/ ) const +{ + print( T ); +} + +void KBorderColTextExport::printNextLine( QString &T ) const +{ + print( T ); +} + +void KBorderColTextExport::print( QString &T ) const +{ + T.append( " | " ); +} diff --git a/khexedit/lib/kbordercoltextexport.h b/khexedit/lib/kbordercoltextexport.h new file mode 100644 index 0000000..4103f0b --- /dev/null +++ b/khexedit/lib/kbordercoltextexport.h @@ -0,0 +1,40 @@ +/*************************************************************************** + kbordercoltextexport.h - description + ------------------- + begin : Sam Aug 30 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBORDERCOLTEXTEXPORT_H +#define KHE_KBORDERCOLTEXTEXPORT_H + +#include "kcoltextexport.h" + +namespace KHE +{ + +class KBorderColTextExport : public KColTextExport +{ + public: // API + void printFirstLine( QString &T, int Line ) const; + void printNextLine( QString &T) const; + /** tells how much chars per line are needed */ + int charsPerLine() const ; + + protected: + void print( QString &T ) const; +}; + +} + +#endif diff --git a/khexedit/lib/kbordercolumn.cpp b/khexedit/lib/kbordercolumn.cpp new file mode 100644 index 0000000..c590246 --- /dev/null +++ b/khexedit/lib/kbordercolumn.cpp @@ -0,0 +1,82 @@ +/*************************************************************************** + kbordercolumn.cpp - description + ------------------- + begin : Mit Mai 21 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// qt specific +#include <qpainter.h> +#include <qstyle.h> +// lib specific +#include "kcolumnsview.h" +#include "kbordercolumn.h" + + +using namespace KHE; + +static const KPixelX DefaultWidth = 9; +static const KPixelX LineX = DefaultWidth / 2; + + +KBorderColumn::KBorderColumn( KColumnsView *V, bool M ) + : KColumn( V ), + Middle( M ) +{ + setWidth( M?DefaultWidth:LineX-1 ); +} + +KBorderColumn::~KBorderColumn() +{ +} + + +void KBorderColumn::paintLine( QPainter *P ) +{ + if( LineHeight > 0 ) + { + KColumn::paintBlankLine( P ); + + if( Middle ) + { + int GridColor = View->style().styleHint( QStyle::SH_Table_GridLineColor, View ); + P->setPen( GridColor != -1 ? (QRgb)GridColor : View->colorGroup().mid() ); + P->drawLine( LineX, 0, LineX, LineHeight-1 ) ; + } + } +} + + +void KBorderColumn::paintFirstLine( QPainter *P, KPixelXs , int ) +{ + paintLine( P ); +} + + +void KBorderColumn::paintNextLine( QPainter *P ) +{ + paintLine( P ); +} + +void KBorderColumn::paintEmptyColumn( QPainter *P, KPixelXs Xs, KPixelYs Ys ) +{ + KColumn::paintEmptyColumn( P,Xs,Ys ); + + KPixelX LX = x() + LineX; + if( Middle && Xs.includes(LX) ) + { + int GridColor = View->style().styleHint( QStyle::SH_Table_GridLineColor, View ); + P->setPen( GridColor != -1 ? (QRgb)GridColor : View->colorGroup().mid() ); + P->drawLine( LX, Ys.start(), LX, Ys.end() ) ; + } +} diff --git a/khexedit/lib/kbordercolumn.h b/khexedit/lib/kbordercolumn.h new file mode 100644 index 0000000..0a72c05 --- /dev/null +++ b/khexedit/lib/kbordercolumn.h @@ -0,0 +1,52 @@ +/*************************************************************************** + kbordercolumn.h - description + ------------------- + begin : Mit Mai 21 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBORDERCOLUMN_H +#define KHE_KBORDERCOLUMN_H + +#include "kcolumn.h" + +namespace KHE +{ + +/** column that does nothing but draw a vertical line in the middle of the column + * + *@author Friedrich W. H. Kossebau + */ + +class KBorderColumn : public KColumn +{ + public: + KBorderColumn( KColumnsView *V, bool M ); + ~KBorderColumn(); + + public: // KColumn-API + virtual void paintFirstLine( QPainter *P, KPixelXs Xs, int FirstLine ); + virtual void paintNextLine( QPainter *P ); + virtual void paintEmptyColumn( QPainter *P, KPixelXs Xs, KPixelYs Ys ); + + protected: + virtual void paintLine( QPainter *P ); + + protected: + /** true if we are between two columns and should show a line */ + bool Middle; +}; + +} + +#endif diff --git a/khexedit/lib/kbuffercoltextexport.cpp b/khexedit/lib/kbuffercoltextexport.cpp new file mode 100644 index 0000000..a4ee91f --- /dev/null +++ b/khexedit/lib/kbuffercoltextexport.cpp @@ -0,0 +1,108 @@ +/*************************************************************************** + kbuffercoltextexport.cpp - description + ------------------- + begin : Sam Aug 30 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// c specific +#include <string.h> +// lib specific +#include "kbuffercolumn.h" +#include "kbufferlayout.h" +#include "kbuffercoltextexport.h" + + +using namespace KHE; + +static const int DefaultTEByteSpacingWidth = 1; +static const int TEGroupSpacingWidth = 3; + +QString KBufferColTextExport::whiteSpace( uint s ) +{ + return QString().fill( ' ', s ); +} + +KBufferColTextExport::KBufferColTextExport( const KBufferColumn* BufferColumn, const char *D, + KCoordRange CR, int ByteWidth ) + : Data( D ), + CoordRange( CR ) +{ + NoOfBytesPerLine = BufferColumn->layout()->noOfBytesPerLine(); + Pos = new int[NoOfBytesPerLine]; + + // TODO: remove this hack and make it more general + int ByteSpacingWidth = BufferColumn->byteSpacingWidth(); + if( ByteSpacingWidth > 0 ) + ByteSpacingWidth = DefaultTEByteSpacingWidth; + + int SpacingTrigger = BufferColumn->noOfGroupedBytes()-1; + if( SpacingTrigger < 0 ) + SpacingTrigger = NoOfBytesPerLine; // ensures to never trigger the group spacing + + int N = 0; + int p = 0; + int gs = 0; + int *P = Pos; + for( ; P<&Pos[NoOfBytesPerLine]; ++P, ++p, ++gs ) + { + *P = N; + N += ByteWidth; + + // is there a space behind the actual byte (if it is not the last)? + if( gs == SpacingTrigger ) + { + N += TEGroupSpacingWidth; + gs = -1; + } + else + N += ByteSpacingWidth; + } + N -= (gs==0)?TEGroupSpacingWidth:ByteSpacingWidth; + + NoOfCharsPerLine = N; +} + + +KBufferColTextExport::~KBufferColTextExport() +{ + delete [] Pos; +} + + +int KBufferColTextExport::charsPerLine() const +{ + return NoOfCharsPerLine; +} + + +void KBufferColTextExport::printFirstLine( QString &T, int Line ) const +{ + PrintLine = Line; + PrintData = Data; + print( T ); +} + + +void KBufferColTextExport::printNextLine( QString &T ) const +{ + print( T ); +} + + +void KBufferColTextExport::print( QString &T ) const +{ + T.append( whiteSpace(NoOfCharsPerLine) ); + ++PrintLine; +} + diff --git a/khexedit/lib/kbuffercoltextexport.h b/khexedit/lib/kbuffercoltextexport.h new file mode 100644 index 0000000..6cb161d --- /dev/null +++ b/khexedit/lib/kbuffercoltextexport.h @@ -0,0 +1,73 @@ +/*************************************************************************** + kbuffercoltextexport.h - description + ------------------- + begin : Sam Aug 30 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBUFFERCOLTEXTEXPORT_H +#define KHE_KBUFFERCOLTEXTEXPORT_H + +// qt specific +#include <qstring.h> +// lib specific +#include "kcoltextexport.h" +#include "kcoordrange.h" + + +namespace KHE +{ + +class KBufferColumn; + + +class KBufferColTextExport : public KColTextExport +{ + public: + KBufferColTextExport( const KBufferColumn* BF, const char *D, KCoordRange CR, int BytesWidth ); + virtual ~KBufferColTextExport(); + + public: // API + void printFirstLine( QString &T, int Line ) const; + void printNextLine( QString &T ) const; + /** tells how much chars per line are needed */ + int charsPerLine() const; + + + protected: // API to be reimplemented by subclasses + virtual void print( QString &T ) const; + + + protected: + static QString whiteSpace( uint s ); + + protected: + const char *Data; + KCoordRange CoordRange; + + int NoOfBytesPerLine; + + /** Line to print */ + mutable int PrintLine; + /** Data to print */ + mutable const char *PrintData; + + /** buffered value of how many chars a line needs */ + int NoOfCharsPerLine; + // positions where to paint the + int *Pos; +}; + +} + +#endif diff --git a/khexedit/lib/kbuffercolumn.cpp b/khexedit/lib/kbuffercolumn.cpp new file mode 100644 index 0000000..4291e00 --- /dev/null +++ b/khexedit/lib/kbuffercolumn.cpp @@ -0,0 +1,700 @@ +/*************************************************************************** + kbuffercolumn.cpp - description + ------------------- + begin : Mit Mai 14 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +//#include <kdebug.h> + +// qt specific +#include <qpainter.h> +// lib specific +#include "kcolumnsview.h" +#include "kbuffercursor.h" +#include "kbuffercolumn.h" +#include "kbufferlayout.h" +#include "kbufferranges.h" +#include "helper.h" +#include "kcharcodec.h" + +using namespace KHE; + +static const unsigned int StartsBefore = 1; +static const unsigned int EndsLater = 2; +static const char EmptyByte = ' '; + +static const KPixelX DefaultCursorWidth = 2; +static const KPixelX DefaultByteSpacingWidth = 3; +static const KPixelX DefaultGroupSpacingWidth = 9; +static const int DefaultNoOfGroupedBytes = 4; + +KBufferColumn::KBufferColumn( KColumnsView *CV, KDataBuffer *B, KBufferLayout *L, KBufferRanges *R ) + : KColumn( CV ), + Buffer( B ), + Layout( L ), + Ranges( R ), + DigitWidth( 0 ), + DigitBaseLine( 0 ), + VerticalGrid( false ), + ByteWidth( 0 ), + ByteSpacingWidth( DefaultByteSpacingWidth ), + GroupSpacingWidth( DefaultGroupSpacingWidth ), + NoOfGroupedBytes( DefaultNoOfGroupedBytes ), + PosX( 0L ), + PosRightX( 0L ), + LastPos( 0 ) +{ +} + + +KBufferColumn::~KBufferColumn() +{ + delete [] PosX; + delete [] PosRightX; +} + + + +void KBufferColumn::set( KDataBuffer *B ) +{ + Buffer= B; +} + + +void KBufferColumn::resetXBuffer() +{ + delete [] PosX; + delete [] PosRightX; + + LastPos = Layout->noOfBytesPerLine()-1; + PosX = new KPixelX[LastPos+1]; + PosRightX = new KPixelX[LastPos+1]; + + if( PosX ) + recalcX(); +} + + +void KBufferColumn::setMetrics( KPixelX DW, KPixelY DBL ) +{ + DigitBaseLine = DBL; + setDigitWidth( DW ); +} + + +bool KBufferColumn::setDigitWidth( KPixelX DW ) +{ + // no changes? + if( DigitWidth == DW ) + return false; + + DigitWidth = DW; + // recalculate depend sizes + recalcByteWidth(); + + if( PosX ) + recalcX(); + return true; +} + + +bool KBufferColumn::setSpacing( KPixelX BSW, int NoGB, KPixelX GSW ) +{ + // no changes? + if( ByteSpacingWidth == BSW && NoOfGroupedBytes == NoGB && GroupSpacingWidth == GSW ) + return false; + + ByteSpacingWidth = BSW; + NoOfGroupedBytes = NoGB; + GroupSpacingWidth = GSW; + + // recalculate depend sizes + recalcVerticalGridX(); + + if( PosX ) + recalcX(); + return true; +} + + +bool KBufferColumn::setByteSpacingWidth( KPixelX BSW ) +{ + // no changes? + if( ByteSpacingWidth == BSW ) + return false; + + ByteSpacingWidth = BSW; + + // recalculate depend sizes + recalcVerticalGridX(); + + if( PosX ) + recalcX(); + return true; +} + + +bool KBufferColumn::setNoOfGroupedBytes( int NoGB ) +{ + // no changes? + if( NoOfGroupedBytes == NoGB ) + return false; + + NoOfGroupedBytes = NoGB; + + if( PosX ) + recalcX(); + return true; +} + + +bool KBufferColumn::setGroupSpacingWidth( KPixelX GSW ) +{ + // no changes? + if( GroupSpacingWidth == GSW ) + return false; + + GroupSpacingWidth = GSW; + + // recalculate depend sizes + recalcVerticalGridX(); + + if( PosX ) + recalcX(); + return true; +} + + +void KBufferColumn::recalcByteWidth() +{ + ByteWidth = DigitWidth; + recalcVerticalGridX(); +} + + +void KBufferColumn::recalcVerticalGridX() +{ + VerticalGridX = ByteWidth-1 + GroupSpacingWidth/2; +} + + +void KBufferColumn::recalcX() +{ + SpacingTrigger = noOfGroupedBytes() > 0 ? noOfGroupedBytes()-1 : LastPos+1; // last ensures to never trigger the spacing + + KPixelX NewWidth = 0; + int p = 0; + int gs = 0; + KPixelX *PX = PosX; + KPixelX *PRX = PosRightX; + for( ; PX<&PosX[LastPos+1]; ++PX, ++PRX, ++p, ++gs ) + { + *PX = NewWidth; + NewWidth += ByteWidth; + *PRX = NewWidth-1; + + // is there a space behind the actual byte (if it is not the last)? + if( gs == SpacingTrigger ) + { + NewWidth += GroupSpacingWidth; + gs = -1; + } + else + NewWidth += ByteSpacingWidth; + } + setWidth( PosRightX[LastPos]+1 ); +} + + +// TODO: why are inlined functions not available as symbols when defined before their use +//TODO: works not precisly for the byte rects but includes spacing and left and right +/*inline*/ int KBufferColumn::posOfX( KPixelX PX ) const +{ + if( !PosX ) + return NoByteFound; + + // translate + PX -= x(); + // search backwards for the first byte that is equalleft to x + for( int p=LastPos; p>=0; --p ) + if( PosX[p] <= PX ) + return p; + + return 0; //NoByteFound; +} + + +int KBufferColumn::magPosOfX( KPixelX PX ) const +{ + if( !PosX ) + return NoByteFound; + + // translate + PX -= x(); + // search backwards for the first byte that is equalleft to x + for( int p=LastPos; p>=0; --p ) + if( PosX[p] <= PX ) + { + // are we close to the right? + if( PosRightX[p]-PX < DigitWidth/2 ) // TODO: perhaps cache also the middle xpos's + ++p; + return p; + } + + return 0; //NoByteFound; +} + + +KSection KBufferColumn::posOfX( KPixelX PX, KPixelX PW ) const +{ + if( !PosX ) + return KSection(); + + // translate + PX -= x(); + int PRX = PX + PW - 1; + + KSection P; + // search backwards for the first byte that is equalleft to x + for( int p=LastPos; p>=0; --p ) + if( PosX[p] <= PRX ) + { + P.setEnd( p ); + for( ; p>=0; --p ) + if( PosX[p] <= PX ) + { + P.setStart( p ); + break; + } + break; + } + + return P; +} + + +KPixelX KBufferColumn::xOfPos( int Pos ) const { return x() + (PosX?PosX[Pos]:0); } +KPixelX KBufferColumn::rightXOfPos( int Pos ) const { return x() + (PosRightX?PosRightX[Pos]:0); } + + +int KBufferColumn::posOfRelX( KPixelX PX ) const +{ + if( !PosX ) + return NoByteFound; + + // search backwards for the first byte that is equalleft to x + for( int p=LastPos; p>=0; --p ) + if( PosX[p] <= PX ) + return p; + + return 0; //NoByteFound; +} + + +KSection KBufferColumn::posOfRelX( KPixelX PX, KPixelX PW ) const +{ + if( !PosX ) + return KSection(); + + int PRX = PX + PW - 1; + + KSection P; + // search backwards for the first byte that is equalleft to x + for( int p=LastPos; p>=0; --p ) + if( PosX[p] <= PRX ) + { + P.setEnd( p ); + for( ; p>=0; --p ) + if( PosX[p] <= PX ) + { + P.setStart( p ); + break; + } + break; + } + + return P; +} + + +KPixelX KBufferColumn::relXOfPos( int Pos ) const { return PosX ? PosX[Pos] : 0; } +KPixelX KBufferColumn::relRightXOfPos( int Pos ) const { return PosRightX ? PosRightX[Pos] : 0; } + + +KPixelXs KBufferColumn::wideXPixelsOfPos( KSection Positions ) const +{ + return KPixelXs( Positions.start()>0?rightXOfPos(Positions.start()-1)+1:xOfPos(Positions.start()), + Positions.end()<LastPos?xOfPos(Positions.end()+1)-1:rightXOfPos(Positions.end()) ); +} + + +KPixelXs KBufferColumn::relWideXPixelsOfPos( KSection Positions ) const +{ + return KPixelXs( Positions.start()>0?relRightXOfPos(Positions.start()-1)+1:relXOfPos(Positions.start()), + Positions.end()<LastPos?relXOfPos(Positions.end()+1)-1:relRightXOfPos(Positions.end()) ); +} + + +void KBufferColumn::preparePainting( KPixelXs Xs ) +{ + Xs.restrictTo( XSpan ); + // translate + Xs.moveBy( -x() ); + + + // store the values + PaintX = Xs.start(); + PaintW = Xs.width(); + + // get line positions to paint + PaintPositions = posOfRelX( PaintX, PaintW ); +} + + +void KBufferColumn::paintFirstLine( QPainter *P, KPixelXs Xs, int FirstLine ) +{ + preparePainting( Xs ); + + PaintLine = FirstLine; + +// kdDebug(1501) << "paintFirstLine:"<<cx<<","<<cw<<"|" <<PaintX<<","<<PaintW << ")\n"; + +// paintPositions( P, PaintLine++, PaintPositions ); + paintLine( P, PaintLine++ ); +} + + +void KBufferColumn::paintNextLine( QPainter *P ) +{ +// paintPositions( P, PaintLine++, PaintPositions ); + paintLine( P, PaintLine++ ); +} + + +void KBufferColumn::paintLine( QPainter *P, int Line ) // TODO: could be removed??? +{ +// kdDebug(1501) << "paintLine line: "<<Line<<" Start: "<<PaintPositions.start()<<" End: "<<PaintPositions.end() << "\n"; + // no bytes to paint? +// if( !Layout->hasContent(Line) ) +// return; + + paintPositions( P, Line, PaintPositions ); +} + + +void KBufferColumn::paintPositions( QPainter *P, int Line, KSection Pos ) +{ + const QColorGroup &CG = View->colorGroup(); + + // clear background + unsigned int BlankFlag = (Pos.start()!=0?StartsBefore:0) | (Pos.end()!=LastPos?EndsLater:0); + paintRange( P, CG.base(), Pos, BlankFlag ); + + // Go through the lines TODO: handle first and last line more effeciently + // check for leading and trailing spaces + KSection Positions( Layout->firstPos(KBufferCoord( Pos.start(), Line )), + Layout->lastPos( KBufferCoord( Pos.end(), Line )) ); + + // no bytes to paint? + if( !Layout->hasContent(Line) ) + return; + + // check for leading and trailing spaces + KSection Indizes( Layout->indexAtCoord(KBufferCoord( Positions.start(), Line )), Positions.width(), false ); + + unsigned int SelectionFlag; + unsigned int MarkingFlag; + KSection Selection; + KSection Marking; + bool HasMarking = Ranges->hasMarking(); + bool HasSelection = Ranges->hasSelection(); + + while( Positions.isValid() ) + { + KSection PositionsPart( Positions ); // set of positions to paint next + KSection IndizesPart( Indizes ); // set of indizes to paint next + // falls Marking nicht mehr gebuffert und noch zu erwarten + if( HasMarking && Marking.endsBefore(IndizesPart.start()) ) + { + // erhebe nächste Markierung im Bereich + HasMarking = isMarked( IndizesPart, &Marking, &MarkingFlag ); + } + // falls Selection nicht mehr gebuffert und noch zu erwarten + if( HasSelection && Selection.endsBefore(IndizesPart.start()) ) + { + // erhebe nächste Selection im Bereich + HasSelection = isSelected( IndizesPart, &Selection, &SelectionFlag ); + } + + if( Marking.start() == IndizesPart.start() ) + { + IndizesPart.setEnd( Marking.end() ); + PositionsPart.setEndByWidth( Marking.width() ); + if( PositionsPart.end() == Layout->lastPos(Line) ) MarkingFlag &= ~EndsLater; + if( PositionsPart.start() == Layout->firstPos(Line)) MarkingFlag &= ~StartsBefore; + paintMarking( P, PositionsPart, IndizesPart.start(), MarkingFlag ); + + } + else if( Selection.includes(IndizesPart.start()) ) + { + if( Selection.startsBehind(IndizesPart.start()) ) + SelectionFlag |= StartsBefore; + bool MarkingBeforeEnd = HasMarking && Marking.start() <= Selection.end(); + + IndizesPart.setEnd( MarkingBeforeEnd ? Marking.start()-1 : Selection.end() ); + PositionsPart.setEndByWidth( IndizesPart.width() ); + + if( MarkingBeforeEnd ) + SelectionFlag |= EndsLater; + if( PositionsPart.end() == Layout->lastPos(Line) ) SelectionFlag &= ~EndsLater; + if( PositionsPart.start() == Layout->firstPos(Line) ) SelectionFlag &= ~StartsBefore; + + paintSelection( P, PositionsPart, IndizesPart.start(), SelectionFlag ); + } + else + { + // calc end of plain text + if( HasMarking ) + IndizesPart.setEnd( Marking.start()-1 ); + if( HasSelection ) + IndizesPart.restrictEndTo( Selection.start()-1 ); + + PositionsPart.setEndByWidth( IndizesPart.width() ); + paintPlain( P, PositionsPart, IndizesPart.start() ); + } + Indizes.setStartBehind( IndizesPart ); + Positions.setStartBehind( PositionsPart ); + } + // we don't paint grids as default, perhaps we never will though it works + // paintGrid( P, Positions ); // TODO: get some unmodified Positions (see three lines before) +} + + +void KBufferColumn::paintPlain( QPainter *P, KSection Positions, int Index ) +{ + // paint all the bytes affected + for( int p=Positions.start(); p<=Positions.end(); ++p,++Index ) + { + KPixelX x = relXOfPos( p ); + + // draw the byte + P->translate( x, 0 ); + char Byte = Buffer->datum( Index ); + KHEChar B = Codec->decode( Byte ); + drawByte( P, Byte, B, colorForChar(B) ); + + P->translate( -x, 0 ); + } +} + + +void KBufferColumn::paintSelection( QPainter *P, KSection Positions, int Index, int Flag ) +{ + const QColorGroup &CG = View->colorGroup(); + + paintRange( P, CG.highlight(), Positions, Flag ); + + const QColor &HTC = CG.highlightedText(); + // paint all the bytes affected + for( int p=Positions.start(); p<=Positions.end(); ++p,++Index ) + { + KPixelX x = relXOfPos( p ); + + // draw the byte + P->translate( x, 0 ); + char Byte = Buffer->datum( Index ); + KHEChar B = Codec->decode( Byte ); + drawByte( P, Byte, B, HTC ); + + P->translate( -x, 0 ); + } +} + + +void KBufferColumn::paintMarking( QPainter *P, KSection Positions, int Index, int Flag ) +{ + const QColorGroup &CG = View->colorGroup(); + + paintRange( P, CG.text(), Positions, Flag ); + + const QColor &BC = CG.base(); + // paint all the bytes affected + for( int p=Positions.start(); p<=Positions.end(); ++p,++Index ) + { + KPixelX x = relXOfPos( p ); + + // draw the byte + P->translate( x, 0 ); + char Byte = Buffer->datum( Index ); + KHEChar B = Codec->decode( Byte ); + drawByte( P, Byte, B, BC ); + + P->translate( -x, 0 ); + } +} + + +// TODO: smarter calculation +void KBufferColumn::paintGrid( QPainter *P, KSection Range ) +{ + int st = 0; // counter for spacing triggering + P->setPen( Qt::black ); + // paint all the bytes affected + for( int p=Range.start(); p<=Range.end(); ++p,++st ) + { + KPixelX x = relXOfPos( p ); + + // draw the byte + P->translate( x, 0 ); + + // spacing behind byte and vertical grid enabled? + if( st == SpacingTrigger && p != LastPos ) + P->drawLine( VerticalGridX, 0, VerticalGridX, LineHeight-1 ) ; + + P->translate( -x, 0 ); + } +} + + +void KBufferColumn::paintRange( QPainter *P, const QColor &Color, KSection Positions, int Flag ) +{ + KPixelX RangeX = Flag & StartsBefore ? relRightXOfPos( Positions.start()-1 ) + 1 : relXOfPos( Positions.start() ); + KPixelX RangeW = (Flag & EndsLater ? relXOfPos( Positions.end()+1 ): relRightXOfPos( Positions.end() ) + 1) - RangeX; + + P->fillRect( RangeX,0,RangeW,LineHeight, QBrush(Color,Qt::SolidPattern) ); +} + + +void KBufferColumn::paintByte( QPainter *P, int Index ) +{ + char Byte = ( Index > -1 ) ? Buffer->datum( Index ) : EmptyByte; + KHEChar B = Codec->decode( Byte ); + + const QColorGroup &CG = View->colorGroup(); + QColor Color = CG.text(); + QBrush Brush( CG.base(), Qt::SolidPattern ); + + if( Index > -1 ) + { + if( Ranges->markingIncludes(Index) ) + { + Brush.setColor( CG.text() ); + Color = CG.base(); + } + else if( Ranges->selectionIncludes(Index) ) + { + Brush.setColor( CG.highlight() ); + Color = CG.highlightedText(); + } + else + { + Brush.setColor( CG.base() ); + Color = colorForChar( B ); + } + } + + P->fillRect( 0,0,ByteWidth,LineHeight, Brush ); + + if( Index > -1 ) + drawByte( P, Byte, B, Color ); +} + + +void KBufferColumn::paintFramedByte( QPainter *P, int Index, KFrameStyle FrameStyle ) +{ + paintByte( P, Index ); + char Byte = ( Index > -1 ) ? Buffer->datum( Index ) : EmptyByte; + KHEChar B = Codec->decode( Byte ); + + P->setPen( colorForChar(B) ); + if( FrameStyle == Frame ) + P->drawRect( 0, 0, ByteWidth, LineHeight ); + else if( FrameStyle == Left ) + P->drawLine( 0, 0, 0, LineHeight-1 ); + else + P->drawLine( ByteWidth-1,0,ByteWidth-1,LineHeight-1 ); +} + + +void KBufferColumn::paintCursor( QPainter *P, int Index ) +{ + char Byte = ( Index > -1 ) ? Buffer->datum( Index ) : EmptyByte; + KHEChar B = Codec->decode( Byte ); + P->fillRect( 0, 0, ByteWidth, LineHeight, QBrush(colorForChar(B),Qt::SolidPattern) ); +} + + +void KBufferColumn::drawByte( QPainter *P, char /*Byte*/, KHEChar B, const QColor &Color ) const +{ + P->setPen( Color ); + P->drawText( 0, DigitBaseLine, B ); +} + + +bool KBufferColumn::isSelected( KSection Range, KSection *Selection, unsigned int *Flag ) const +{ + KSection S; + unsigned int F = 0; + const KSection *OS = Ranges->firstOverlappingSelection( Range ); + if( !OS ) + return false; + S = *OS; + + // does selection start before asked range? + if( Range.start() > S.start() ) + { + S.setStart( Range.start() ); + F |= StartsBefore; + } + + // does selection go on behind asked range? + if( Range.end() < S.end() ) + { + S.setEnd( Range.end() ); + F |= EndsLater; + } + + *Selection = S; + *Flag = F; + return true; +} + + +bool KBufferColumn::isMarked( KSection Range, KSection *Marking, unsigned int *Flag ) const +{ + KSection M; + unsigned int F = 0; + const KSection *OM = Ranges->overlappingMarking( Range ); + if( !OM ) + return false; + M = *OM; + + // does selection start before asked range? + if( Range.start() > M.start() ) + { + M.setStart( Range.start() ); + F |= StartsBefore; + } + + // does selection go on behind asked range? + if( Range.end() < M.end() ) + { + M.setEnd( Range.end() ); + F |= EndsLater; + } + + *Marking = M; + *Flag = F; + return true; +} diff --git a/khexedit/lib/kbuffercolumn.h b/khexedit/lib/kbuffercolumn.h new file mode 100644 index 0000000..76ed8bc --- /dev/null +++ b/khexedit/lib/kbuffercolumn.h @@ -0,0 +1,253 @@ +/*************************************************************************** + kbuffercolumn.h - description + ------------------- + begin : Mit Mai 14 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBUFFERCOLUMN_H +#define KHE_KBUFFERCOLUMN_H + +// lib specific +#include "khe.h" +#include "kdatabuffer.h" +#include "khechar.h" +#include "kcolumn.h" +#include "kbufferlayout.h" +#include "ksection.h" + +class QPainter; +class QColor; + +namespace KHE +{ + +// class KHexEdit; +class KBufferRanges; +class KCharCodec; + +const int NoByteFound = -1; + +/** base class of all buffer column displayers + * holds all information about the vertical layout of a buffer column + * knows how to paint the data and the editing things (focus, cursor, selection) + * but does not offer + * + *@author Friedrich W. H. Kossebauint KBufferColumn::posOfX( KPixelX PX, bool *ToTheRightFlag ) const + */ +class KBufferColumn : public KColumn +{ + public: + enum KFrameStyle { Frame, Left, Right }; + public: + KBufferColumn( KColumnsView/*KHexEdit*/ *HE, KDataBuffer *B, KBufferLayout *L, KBufferRanges *R ); + virtual ~KBufferColumn(); + + + public: // KColumn-API + virtual void paintFirstLine( QPainter *P, KPixelXs Xs, int FirstLine ); + virtual void paintNextLine( QPainter *P ); + + public: + void preparePainting( KPixelXs Xs ); + + public: + void paintLine( QPainter *P, int Line ); + void paintPositions( QPainter *P, int Line, KSection Positions ); + /** paints a cursor based on the type of the byte. + * @param Index Index of the byte to paint the cursor for. If -1 a space is used as char. + */ + void paintCursor( QPainter *P, int Index ); + /** paints the byte with background. + * @param Index Index of the byte to paint. If -1 only the background is painted. + */ + void paintByte( QPainter *P, int Index ); + /** paints the byte with background and a frame around. + * @param Index Index of the byte to paint the frame for. If -1 a space is used as char. + * @param Style the style of the framing + */ + void paintFramedByte( QPainter *P, int Index, KFrameStyle Style ); + + + public: // modification access + /** sets the spacing in the hex column + * @param ByteSpacingW spacing between the bytes in pixels + * @param NewNoOfGroupedBytes numbers of grouped bytes, 0 means no grouping + * @param GroupSpacingW spacing between the groups in pixels + * returns true if there was a change + */ + bool setSpacing( KPixelX ByteSpacingW, int NewNoOfGroupedBytes = 0, KPixelX GroupSpacingW = 0 ); + /** sets the spacing between the bytes in the hex column + * @param ByteSpacingW spacing between the bytes in pixels + * returns true if there was a change + */ + bool setByteSpacingWidth( KPixelX ByteSpacingW ); + /** sets the number of grouped bytes in the hex column + * @param NewNoOfGroupedBytes numbers of grouped bytes, 0 means no grouping + * returns true if there was a change + */ + bool setNoOfGroupedBytes( int NewNoOfGroupedBytes ); + /** sets the spacing between the groups of bytes in the hex column + * @param GroupSpacingW spacing between the groups in pixels + * returns true if there was a change + */ + bool setGroupSpacingWidth( KPixelX GroupSpacingW ); + /** sets width of digits and recalculates depend sizes + * returns true if there was a change + */ + bool setDigitWidth( KPixelX DW ); + /** sets the metrics of the used font + * @param NewDigitWidth the new width of a digit + * @param NewDigitBaseLine the new baseline of the digits + */ + void setMetrics( KPixelX NewDigitWidth, KPixelY NewDigitBaseLine ); + /** */ + void set( KDataBuffer *B ); + /** creates new buffer for x-values; to be called on any change of NoOfBytesPerLine or metrics */ + void resetXBuffer(); + /** sets the codec to be used by the char column. */ + void setCodec( KCharCodec *C ); + + public: // functional logic + /** returns byte positions covered by pixels with absolute x-coord x */ + KSection posOfX( KPixelX x, KPixelX w ) const; + /** returns byte pos at pixel with absolute x-coord x */ + int posOfX( KPixelX x ) const; + /** returns byte pos at pixel with absolute x-coord x, and sets the flag to true if we are closer to the right */ + int magPosOfX( KPixelX PX ) const; + /** returns absolute x-coord of byte at position Pos */ + KPixelX xOfPos( int Pos ) const; + /** returns right absolute x-coord of byte at position Pos */ + KPixelX rightXOfPos( int Pos ) const; + /** returns byte pos at pixel with relative x-coord x */ + int posOfRelX( KPixelX x ) const; + /** returns byte positions covered by pixels with relative x-coord x */ + KSection posOfRelX( KPixelX x, KPixelX w ) const; + /** returns relative x-coord of byte at position Pos */ + KPixelX relXOfPos( int Pos ) const; + /** returns right relative x-coord of byte at position Pos */ + KPixelX relRightXOfPos( int Pos ) const; + /** returns the positions that overlap with the absolute x-coords */ + KSection visiblePositions( KPixelX x, KPixelX w ) const; + /** returns the */ + KPixelXs wideXPixelsOfPos( KSection Positions ) const; + /** */ + KPixelXs relWideXPixelsOfPos( KSection Positions ) const; + + public: // value access + KPixelX byteWidth() const; + KPixelX digitWidth() const; + KPixelX groupSpacingWidth() const; + KPixelX byteSpacingWidth() const; + int noOfGroupedBytes() const; + + int firstPos() const; + int lastPos() const; + KSection visiblePositions() const; + const KBufferLayout *layout() const; + KCharCodec* codec() const; + + protected: + /** */ + void recalcX(); + void recalcVerticalGridX(); + + + protected: // API to be refined + /** default implementation simply prints the byte as ASCII */ + virtual void drawByte( QPainter *P, char Byte, KHEChar B, const QColor &Color ) const; + /** default implementation sets byte width to one digit width */ + virtual void recalcByteWidth(); + + + protected: + void paintGrid( QPainter *P, KSection Range ); + void paintPlain( QPainter *P, KSection Positions, int Index ); + void paintSelection( QPainter *P, KSection Positions, int Index, int Flag ); + void paintMarking( QPainter *P, KSection Positions, int Index, int Flag ); + void paintRange( QPainter *P, const QColor &Color, KSection Positions, int Flag ); + + bool isSelected( KSection Range, KSection *Selection, unsigned int *Flag ) const; + bool isMarked( KSection Range, KSection *Marking, unsigned int *Flag ) const; + + + protected: + /** pointer to the buffer */ + KDataBuffer *Buffer; + /** pointer to the layout */ + const KBufferLayout *Layout; + /** pointer to the ranges */ + KBufferRanges *Ranges; + /** */ + KCharCodec *Codec; + + /** */ + KPixelX DigitWidth; + /** */ + KPixelY DigitBaseLine; + /** */ + KPixelX VerticalGridX; + /** */ + bool VerticalGrid; + + protected: // individual data + /** total width of byte display in pixel */ + KPixelX ByteWidth; + /** width of inserting cursor in pixel */ + KPixelX CursorWidth; + /** size of the line margin */ + KPixelX ByteSpacingWidth; + /** width of spacing in pixel */ + KPixelX GroupSpacingWidth; + + /** number of grouped bytes */ + int NoOfGroupedBytes; + + /** pointer to array with buffered positions (relative to column position) + * a spacing gets assigned to the left byte -> ...c|c|c |c|c... + */ + KPixelX *PosX; + KPixelX *PosRightX; + /** index of right position */ + int LastPos; + + + protected: // buffering drawing data + KSection PaintPositions; + int PaintLine; + KPixelX PaintX; + KPixelX PaintW; + int SpacingTrigger; +}; + + +inline KPixelX KBufferColumn::byteWidth() const { return ByteWidth; } +inline KPixelX KBufferColumn::digitWidth() const { return DigitWidth; } +inline KPixelX KBufferColumn::byteSpacingWidth() const { return ByteSpacingWidth; } +inline KPixelX KBufferColumn::groupSpacingWidth() const { return GroupSpacingWidth; } + +inline int KBufferColumn::noOfGroupedBytes() const { return NoOfGroupedBytes; } + +inline int KBufferColumn::firstPos() const { return PaintPositions.start(); } +inline int KBufferColumn::lastPos() const { return PaintPositions.end(); } +inline KSection KBufferColumn::visiblePositions() const { return PaintPositions; } + +inline const KBufferLayout *KBufferColumn::layout() const { return Layout; } + + +inline void KBufferColumn::setCodec( KCharCodec *C ) { Codec = C; } +inline KCharCodec* KBufferColumn::codec() const { return Codec; } + +} + +#endif diff --git a/khexedit/lib/kbuffercoord.h b/khexedit/lib/kbuffercoord.h new file mode 100644 index 0000000..997551a --- /dev/null +++ b/khexedit/lib/kbuffercoord.h @@ -0,0 +1,293 @@ +/*************************************************************************** + kbuffercoord.h - description + ------------------- + begin : Don Mai 29 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBUFFERCOORD_H +#define KHE_KBUFFERCOORD_H + + +namespace KHE +{ + +/** + * a class which represents a coord in a 2-dim. system + * + * It consists of a line number and a position in the line. + * The coord starts at (0,0). Line numbers increase downwards, positions to the right. + * With any of both at a negative number the coord is invalid. + * TODO: change as much as possible params to unsigned integer + * + * @author Friedrich W. H. Kossebau + */ +class KBufferCoord +{ + public: + /** creates a coord with 0,0 */ + KBufferCoord(); + KBufferCoord( int P, int L ); + KBufferCoord( int Index, int LineWidth, bool /*dummy*/ ); + KBufferCoord( const KBufferCoord &C ); + KBufferCoord &operator=( const KBufferCoord &c ); + ~KBufferCoord(); + + + public: // logic + bool operator==( const KBufferCoord &c ) const; + bool operator!=( const KBufferCoord &c ) const; + bool operator<( const KBufferCoord &c ) const; + bool operator<=( const KBufferCoord &c ) const; + bool operator>( const KBufferCoord &c ) const; + bool operator>=( const KBufferCoord &c ) const; + + /** tests if the coord is prior in the same line than the given coord. + * If at least one of both is invalid the result is undefined. + * @return true if the pos is left to the pos of C and both are in the same line, otherwise false. + */ + bool isPriorInLineThan( const KBufferCoord &C ) const; + /** tests if the coord is later in the same line than the given coord. + * If at least one of both is invalid the result is undefined. + * @return true if the pos is right to the pos of C and both are in the same line, otherwise false + */ + bool isLaterInLineThan( const KBufferCoord &C ) const; + /** @return true if the line is below L, otherwise false */ + bool isBelow( int L ) const; + /** @return true if the line is above L, otherwise false */ + bool isAbove( int L ) const; + /** @return true if the coord is at (0,0) */ + bool isAtStart() const; + /** @return true if the pos is greater than 0, otherwise false */ + bool isBehindLineStart() const; + /** @return true if the pos is smaller than MaxPos, otherwise false */ + bool isBeforeLineEnd( int MaxPos ) const; + + /** calculates the index the coord is at with a given line width + * If the coord is invalid the result is undefined. + * @param LineWidth given width of line + * @return index the coord is at + */ + int indexByLineWidth( int LineWidth ) const; + + public: + /** set the coord by calculating it for an index with a given line width + * @param Index index in the buffer + * @param LineWidth given line width + */ + void setByIndexNWidth( int Index, int LineWidth ); + /** sets both position and line */ + void set( int P, int L ); + /** sets the position */ + void setPos( int P ); + /** sets the line */ + void setLine( int L ); + + /** moves the coord one position to the left. If the coord is invalid the result is undefined. */ + void goLeft(); + /** moves the coord a given number of positions to the left. + * If the coord is invalid the result is undefined or the position smaller then the given number + * the behaviour is undefined. + * @param P number of positions + */ + void goLeft( unsigned int P ); + /** moves the coord one position to the left, or if the position is already at the line start + * to the given position in the previous line. If the coord is invalid the result is undefined. + * @param MaxPos maximal allowed position + */ + void goCLeft( int MaxPos ); + /** moves the coord one position to the right. If the coord is invalid the result is undefined. */ + void goRight(); + /** moves the coord a given number of positions to the right. If the coord is invalid the result is undefined. + * @param P number of positions + */ + void goRight( unsigned int P ); + /** moves the coord one position to the right, or if the position has already reached or passed MaxPos + * to the first position in the next line. If the coord is invalid the result is undefined. + * @param MaxPos maximal allowed position + */ + void goCRight( int MaxPos ); + /** sets coord to (0,0) */ + void gotoStart(); + void gotoEndOfPreviousLine( int LastPos ); + /** sets the coord to the start of the next line. + * If the coord is invalid the behaviour is undefined. + */ + void gotoStartOfNextLine(); + /** sets the position to the start of the line or + * if the line is the same as that of the given coord to the position of it. + * If one or more of the coords is invalid the behaviour is undefined. + * @param C a possible line start coord + */ + void goLineStart( const KBufferCoord &C ); + /** sets the position to the given pos or + * if the line is the same as that of the given coord to the position of that. + * If one or more of the coords is invalid the behaviour is undefined. + * @param L last position in normal line + * @param C a possible line end coord + */ + void goLineEnd( int L, const KBufferCoord &C ); + /** moves the coord 1 lines upwards. There is no check whether the first line is overstepped. */ + void goUp(); + /** moves the coord L lines downwards. */ + void goDown(); + /** moves the coord L lines upwards. There is no check whether the first line is overstepped. + * @param L number of lines + */ + void goUp( unsigned int L ); + /** moves the coord L lines downwards. + * @param L number of lines + */ + void goDown( unsigned int L ); + + public: // state value access + /** @return the pos in the line */ + int pos() const; + /** @return the line number */ + int line() const; + /** @return true if the coord is valid */ + bool isValid() const; + + private: // member variables + /** Position in Line */ + int Pos; + /** Line */ + int Line; +}; + + +inline KBufferCoord::KBufferCoord() : Pos( 0 ), Line( 0 ) {} +inline KBufferCoord::KBufferCoord( int P, int L ) : Pos( P ), Line( L ) {} +inline KBufferCoord::KBufferCoord( int Index, int LineWidth, bool ) +{ + Line = Index / LineWidth; + Pos = Index - Line*LineWidth; +} + +inline KBufferCoord::KBufferCoord( const KBufferCoord &C ) : Pos( C.Pos ), Line( C.Line ) {} +inline KBufferCoord &KBufferCoord::operator=( const KBufferCoord &C ) { Pos = C.Pos; Line = C.Line; return *this; } +inline KBufferCoord::~KBufferCoord() {} + +inline bool KBufferCoord::operator==( const KBufferCoord &C ) const { return Pos == C.Pos && Line == C.Line; } +inline bool KBufferCoord::operator!=( const KBufferCoord &C ) const { return !(*this == C); } + +inline bool KBufferCoord::operator<( const KBufferCoord &C ) const +{ return Line < C.Line || (Line == C.Line && Pos<C.Pos); } +inline bool KBufferCoord::operator<=( const KBufferCoord &C ) const +{ return Line < C.Line || (Line == C.Line && Pos<=C.Pos); } +inline bool KBufferCoord::operator>( const KBufferCoord &C ) const +{ return Line > C.Line || (Line == C.Line && Pos>C.Pos); } +inline bool KBufferCoord::operator>=( const KBufferCoord &C ) const +{ return Line > C.Line || (Line == C.Line && Pos>=C.Pos); } + +inline int KBufferCoord::pos() const { return Pos; } +inline int KBufferCoord::line() const { return Line; } +inline bool KBufferCoord::isValid() const { return Line >= 0 && Pos >= 0; } + +inline void KBufferCoord::setByIndexNWidth( int Index, int LineWidth ) +{ + Line = Index / LineWidth; + Pos = Index - Line*LineWidth; +} + +inline void KBufferCoord::set( int P, int L ) +{ + Pos = P; + Line = L; +} +inline void KBufferCoord::setPos( int P ) { Pos = P; } +inline void KBufferCoord::setLine( int L ) { Line = L; } + +inline void KBufferCoord::goCRight( int MaxPos ) +{ + if( isBeforeLineEnd(MaxPos) ) + goRight(); + else + gotoStartOfNextLine(); +} +inline void KBufferCoord::goCLeft( int MaxPos ) +{ + if( isBehindLineStart() ) + goLeft(); + else + gotoEndOfPreviousLine( MaxPos ); +} + +inline void KBufferCoord::goRight() { ++Pos; } +inline void KBufferCoord::goLeft() { --Pos; } +inline void KBufferCoord::goRight( unsigned int P ) { Pos += P; } +inline void KBufferCoord::goLeft( unsigned int P ) { Pos -= P; } + +inline void KBufferCoord::gotoStart() { Pos = Line = 0; } + +inline void KBufferCoord::gotoEndOfPreviousLine( int LastPos ) +{ + --Line; + Pos = LastPos; +} + +inline void KBufferCoord::gotoStartOfNextLine() +{ + ++Line; + Pos = 0; +} + + +inline void KBufferCoord::goLineStart( const KBufferCoord &C ) +{ + Pos = ( Line == C.Line ) ? C.Pos : 0; +} + +inline void KBufferCoord::goLineEnd( int L, const KBufferCoord &C ) +{ + Pos = ( Line == C.Line ) ? C.Pos : L; +} + +inline void KBufferCoord::goUp() { --Line; } +inline void KBufferCoord::goDown() { ++Line; } +inline void KBufferCoord::goUp( unsigned int L ) { Line -= L; } +inline void KBufferCoord::goDown( unsigned int L ) { Line += L; } + + +inline int KBufferCoord::indexByLineWidth( int LineWidth ) const +{ + return Line * LineWidth + Pos; +} + + +inline bool KBufferCoord::isPriorInLineThan( const KBufferCoord &C ) const +{ + return Line == C.Line && Pos < C.Pos; +} + +inline bool KBufferCoord::isLaterInLineThan( const KBufferCoord &C ) const +{ + return Line == C.Line && Pos > C.Pos; +} + +inline bool KBufferCoord::isBelow( int L ) const { return Line > L; } +inline bool KBufferCoord::isAbove( int L ) const { return Line < L; } + +inline bool KBufferCoord::isBehindLineStart() const { return Pos > 0; } +inline bool KBufferCoord::isBeforeLineEnd( int MaxPos ) const { return Pos < MaxPos; } + +inline bool KBufferCoord::isAtStart() const { return Pos == 0 && Line == 0; } + +inline KBufferCoord operator+( const KBufferCoord &C, int p ) +{ + return KBufferCoord( C.pos()+p, C.line() ); +} + +} + +#endif diff --git a/khexedit/lib/kbuffercursor.cpp b/khexedit/lib/kbuffercursor.cpp new file mode 100644 index 0000000..0255d2d --- /dev/null +++ b/khexedit/lib/kbuffercursor.cpp @@ -0,0 +1,365 @@ +/*************************************************************************** + kbuffercursor.cpp - description + ------------------- + begin : Don Mai 29 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +//#include <kdebug.h> + +// lib specific +#include "kbufferlayout.h" +#include "kbuffercursor.h" + +using namespace KHE; + +KBufferCursor::KBufferCursor( const KBufferLayout *L ) + : Layout( L ), + Index( 0 ), + Coord( 0, 0 ), + Behind( false ), + AppendPosEnabled( false ) +{ +} + +KBufferCursor::~KBufferCursor() +{ +} + + +bool KBufferCursor::operator==( const KBufferCursor &C ) const +{ + return Index == C.Index && Behind == C.Behind ; +} + + +void KBufferCursor::setAppendPosEnabled( bool APE ) +{ + if( AppendPosEnabled == APE ) + return; + + AppendPosEnabled = APE; + // reposition Cursor + int Length = Layout->length(); + // behind buffer end, not end of line and not empty? + if( realIndex() >= Length && Coord.pos() < Layout->noOfBytesPerLine()-1 && Length > 0 ) + { + if( AppendPosEnabled ) + { + ++Index; + Coord.goRight(); + Behind = false; + } + else + { + --Index; + Coord.goLeft(); + Behind = true; + } + } +} + + +void KBufferCursor::gotoPreviousByte() +{ + if( Behind ) + Behind = false; + else if( Index > 0 ) + { + --Index; + Coord.goCLeft( Layout->noOfBytesPerLine()-1 ); + } +} + + +void KBufferCursor::gotoPreviousByte( int D ) +{ + if( Behind ) + { + --D; + Behind = false; + } + if( D > Index ) + { + if( Index == 0 ) + return; + gotoStart(); + } + gotoIndex( Index - D ); +} + + +void KBufferCursor::gotoNextByte() +{ + int Length = Layout->length(); + + if( Index < Length ) + { + if( Index == Length-1 ) + stepToEnd(); + else + { + ++Index; + Coord.goCRight( Layout->noOfBytesPerLine()-1 ); + Behind = false; + } + } +} + + +void KBufferCursor::gotoNextByte( int D ) // TODO: think about consistency with gotoNextByte!!! +{ + if( Behind ) + { + ++D; + Behind = false; + } + // would we end behind the end? + if( Index+D >= Layout->length() ) + gotoEnd(); + else + gotoIndex( Index + D ); +} + + +void KBufferCursor::gotoNextByteInLine() +{ + int Length = Layout->length(); + + if( Index < Length ) + { + if( Index == Length-1 ) + stepToEnd(); + else + { + ++Index; + + if( Coord.pos() < Layout->noOfBytesPerLine()-1 ) + Coord.goRight(); + else + Behind = true; + } + } +} + + +void KBufferCursor::gotoUp() +{ + // can we even go up? + if( Coord.isBelow(Layout->startLine()) ) + { + Coord.goUp(); + if( Coord.isPriorInLineThan(Layout->start()) ) + { + Index = 0; + Coord.setPos( Layout->startPos() ); + Behind = false; + } + else + { + Index -= Layout->noOfBytesPerLine(); + if( Behind && !atLineEnd() ) + { + ++Index; + Coord.goRight(); + Behind = false; + } + } + } +} + + +void KBufferCursor::gotoDown() +{ + if( Coord.isAbove(Layout->finalLine()) ) + { + Coord.goDown(); + // behind End? + if( Coord.isLaterInLineThan(Layout->final()) ) + gotoEnd(); + else + Index += Layout->noOfBytesPerLine(); + } +} + + +void KBufferCursor::gotoLineStart() +{ + int OldIndex = Index; + Index = Layout->indexAtLineStart( Coord.line() ); + Coord.goLeft( OldIndex-Index ); + Behind = false; +} + + +void KBufferCursor::gotoLineEnd() +{ + if( Index < Layout->length() ) + { + int OldIndex = Index; + Index = Layout->indexAtLineEnd( Coord.line() ); + Coord.goRight( Index-OldIndex ); + + stepToEnd(); + } +} + + +void KBufferCursor::gotoStart() +{ + Index = 0; + Coord = Layout->start(); + Behind = false; +} + + +void KBufferCursor::gotoEnd() +{ + int Length = Layout->length(); + if( Length > 0 ) + { + Index = Length-1; + Coord = Layout->final(); + + stepToEnd(); + } + else + gotoStart(); +} + + +void KBufferCursor::gotoCIndex( int i ) +{ + if( Layout->length() > 0 ) + { + Index = Layout->correctIndex( i ); + Coord = Layout->coordOfIndex( Index ); + if( i > Index ) + stepToEnd(); + else + Behind = false; + } + else + gotoStart(); +} + + +void KBufferCursor::gotoCCoord( const KBufferCoord &C ) +{ + if( Layout->length() > 0 ) + { + Coord = Layout->correctCoord( C ); + Index = Layout->indexAtCoord( Coord ); + if( C > Coord ) + stepToEnd(); + else + Behind = false; + } + else + gotoStart(); +} + + +void KBufferCursor::stepToEnd() +{ + if( AppendPosEnabled && (Coord.pos() < Layout->noOfBytesPerLine()-1) ) + { + ++Index; + Coord.goRight(); + Behind = false; + } + else + Behind = true; +} + + +void KBufferCursor::gotoIndex( int i ) +{ + Index = i; + Coord = Layout->coordOfIndex( Index ); + Behind = false; +} + + +void KBufferCursor::gotoRealIndex() +{ + if( Behind ) + { + ++Index; + Coord = Layout->coordOfIndex( Index ); + Behind = false; + } +} + + +void KBufferCursor::gotoCoord( const KBufferCoord &C ) +{ + Index = Layout->indexAtCoord( C ); + Coord = C; + Behind = false; +} + + +void KBufferCursor::updateCoord() +{ + Coord = Layout->coordOfIndex( Index ); +} + +// page down should be: one page minus one line +// -> if in the very first line page down will put the cursor on the same page into the last line +void KBufferCursor::gotoPageUp() +{ + int NoOfLinesPerPage = Layout->noOfLinesPerPage(); + int NewIndex = Index - NoOfLinesPerPage * Layout->noOfBytesPerLine(); + if( NewIndex < 0 ) + gotoStart(); + else + { + Index = NewIndex; + Coord.goUp( NoOfLinesPerPage ); + if( Behind && !atLineEnd() ) + { + ++Index; + Coord.goRight(); + Behind = false; + } + } +} + + +void KBufferCursor::gotoPageDown() +{ + int NoOfLinesPerPage = Layout->noOfLinesPerPage(); + int NewIndex = Index + NoOfLinesPerPage * Layout->noOfBytesPerLine(); + if( NewIndex >= Layout->length() ) + gotoEnd(); + else + { + Index = NewIndex; + Coord.goDown( NoOfLinesPerPage ); + } +} + + +int KBufferCursor::validIndex() const { return Index < Layout->length() ? Index : -1; } +int KBufferCursor::indexAtLineStart() const { return Layout->indexAtLineStart( Coord.line() ); } +int KBufferCursor::indexAtLineEnd() const { return Layout->indexAtLineEnd( Coord.line() ); } + + +bool KBufferCursor::atStart() const { return Index == 0; } +bool KBufferCursor::atEnd() const { return Index == Layout->length() - 1; } +bool KBufferCursor::atAppendPos() const { return realIndex() >= Layout->length(); } + + +bool KBufferCursor::atLineStart() const { return Layout->atLineStart( Coord ); } +bool KBufferCursor::atLineEnd() const { return Layout->atLineEnd( Coord ); } diff --git a/khexedit/lib/kbuffercursor.h b/khexedit/lib/kbuffercursor.h new file mode 100644 index 0000000..855b3e8 --- /dev/null +++ b/khexedit/lib/kbuffercursor.h @@ -0,0 +1,172 @@ +/*************************************************************************** + kbuffercursor.h - description + ------------------- + begin : Don Mai 29 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBUFFERCURSOR_H +#define KHE_KBUFFERCURSOR_H + +#include "kbuffercoord.h" + + +namespace KHE +{ + +class KBufferLayout; + + +/**@short navigates through the buffer in an abstract way, based on the layout + * + * The cursor is allowed to access every coord that has content as + * described in the layout. It holds the coord of the actual position + * and the according index in the data array. + * + * To enable the cursor to be placed behind the last position in a line + * (e.g, to mark all data in the line without placing the cursor to the + * beginning of the next line) there is a flag Behind that should be read + * as that the real index the cursor is at is the current one + 1 + * (as returned by realIndex()) + * + * For appending new data to the buffer there is also the need to be able + * to place the cursor at a position behind the last byte. This can be + * enabled by calling setAppendPosEnabled(true). If the cursor is placed to + * this position it gets the (real) index of the last byte + 1. As this + * index does not point to an existing byte validIndex() returns -1. + * Check for atAppendPos() to see whether cursor is at this position. + * + * If the buffer is empty there is no navigation possible, of course. + * The cursor will be placed to coord 0/0 with index 1, Behind=false. + * + *@author Friedrich W. H. Kossebau + */ +class KBufferCursor +{ + public: + KBufferCursor( const KBufferLayout *L ); + ~KBufferCursor(); + + + public: + bool operator==( const KBufferCursor &c ) const; + bool operator!=( const KBufferCursor &c ) const { return !(*this == c); } + + public: // modificator + void setAppendPosEnabled( bool APE=true ); + + public: // state value access + /** the index that is drawn at the actual coord */ + int index() const; + /** the pos of the actual coord */ + int pos() const; + /** the line of the actual coord */ + int line() const; + /** the actual coord */ + KBufferCoord coord() const; + /** true if the cursor is located to the right of the actual coord but still shown at the coord */ + bool isBehind() const; + /** returns the real index. That is if the cursor is tagged as "behind" the current index + * it's real index is the next one. + * Attention: this could be outside the data's range if the cursor is behind the last byte! + */ + int realIndex() const; + /** returns the true index if it is valid index that is it is inside the data's range. + * Otherwise -1 is returned + */ + int validIndex() const; + + //bool isValid() const; + bool appendPosEnabled() const; + + public: // index calculation service + /** returns the index at the start of the cursor's line */ + int indexAtLineStart() const; + /** returns the index at the end of the cursor's line */ + int indexAtLineEnd() const; + + public: // navigation commands + void gotoIndex( int I ); + void gotoCoord( const KBufferCoord &C ); + void gotoCIndex( int I ); + void gotoCCoord( const KBufferCoord &C ); + void gotoRealIndex(); + + void gotoPreviousByte(); + void gotoNextByte(); + void gotoPreviousByte( int D ); + void gotoNextByte( int D ); + void gotoNextByteInLine(); + void gotoUp(); + void gotoDown(); + void gotoLineStart(); + void gotoLineEnd(); + void gotoStart(); + void gotoEnd(); + void gotoPageUp(); + void gotoPageDown(); + + /** puts the cursor behind the actual position if it isn't already*/ + void stepBehind(); + void updateCoord(); + + + public: // logical state access + bool atStart() const; + bool atEnd() const; + /** could only be true in InsertMode: Cursor is behind the last byte */ + bool atAppendPos() const; + bool atLineStart() const; + bool atLineEnd() const; + + + protected: + /** if newpos allowed steps at a coord behind the last existing + * or, if that is at a line end, behind the line + * does not check for empty content! + */ + void stepToEnd(); + + private: + /** layout, tells how the column is organized */ + const KBufferLayout *Layout; + + /** Position in buffer */ + int Index; + /** Position and Line */ + KBufferCoord Coord; + + /** tells whether the cursor is actually behind the actual position. + * This is used for selection to the end of a line or of the whole buffer. + */ + bool Behind : 1; + + /** tells whether there could be a position behind the end of the layout */ + bool AppendPosEnabled : 1; +}; + + +inline int KBufferCursor::index() const { return Index; } +inline int KBufferCursor::pos() const { return Coord.pos(); } +inline int KBufferCursor::line() const { return Coord.line(); } +inline KBufferCoord KBufferCursor::coord() const { return Coord; } +inline bool KBufferCursor::isBehind() const { return Behind; } +inline int KBufferCursor::realIndex() const { return Behind ? Index + 1 : Index; } + +inline void KBufferCursor::stepBehind() { Behind = true; } + +//inline bool KBufferCursor::isValid() const { return Index != -1; } + +} + +#endif diff --git a/khexedit/lib/kbufferdrag.cpp b/khexedit/lib/kbufferdrag.cpp new file mode 100644 index 0000000..199982c --- /dev/null +++ b/khexedit/lib/kbufferdrag.cpp @@ -0,0 +1,237 @@ +/*************************************************************************** + kbufferdrag.cpp - description + ------------------- + begin : Mon Jul 07 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// qt specific +#include <qcstring.h> +#include <qtextcodec.h> +// kde specific +#include <kglobal.h> +#include <klocale.h> +// lib specific +#include "kbordercoltextexport.h" +#include "koffsetcoltextexport.h" +#include "kvaluecoltextexport.h" +#include "kcharcoltextexport.h" +#include "kcharcodec.h" +#include "kbufferdrag.h" + + +using namespace std; +using namespace KHE; + +static const char OctetStream[] = "application/octet-stream"; +static const char TextPlainUTF8[] = "text/plain;charset=UTF-8"; +static const char TextPlain[] = "text/plain"; +static const char TextPlainLocalStub[] = "text/plain;charset="; + +//static const char *BaseTypes[3] = { OctetStream, TextPlainUTF8, TextPlain }; + +// creates the name for the local text/plain +static const char *localTextPlain() +{ + static QCString TextPlainLocal; + + if( TextPlainLocal.isNull() ) + { + TextPlainLocal = QCString(KGlobal::locale()->encoding()).lower(); + // remove the whitespaces + int s; + while( (s=TextPlainLocal.find(' ')) >= 0 ) + TextPlainLocal.remove( s, 1 ); + + TextPlainLocal.prepend( TextPlainLocalStub ); + } + + return TextPlainLocal; +} + +// tries to create a codec by the given charset description +static QTextCodec* codecForCharset( const QCString& Desc ) +{ + int i = Desc.find( "charset=" ); + if( i >= 0 ) + { + QCString CharSetName = Desc.mid( i+8 ); + // remove any further attributes + if( (i=CharSetName.find( ';' )) >= 0 ) + CharSetName = CharSetName.left( i ); + + // try to find codec + return QTextCodec::codecForName( CharSetName ); + } + // no charset=, use locale + return KGlobal::locale()->codecForEncoding(); +} + + + +KBufferDrag::KBufferDrag( const QByteArray &D, KCoordRange Range, + const KOffsetColumn *OC, const KValueColumn *HC, const KCharColumn *TC, + QChar SC, QChar UC, const QString &CN, + QWidget *Source, const char *Name ) + :QDragObject( Source, Name ), + CoordRange( Range ), + NoOfCol( 0 ), + SubstituteChar( SC ), + UndefinedChar( UC ), + CodecName( CN ) +{ + setData( D ); + + // print column wise? + if( HC || TC ) + { + if( OC ) + { + Columns[NoOfCol++] = new KOffsetColTextExport( OC ); + Columns[NoOfCol++] = new KBorderColTextExport(); + } + if( HC ) + Columns[NoOfCol++] = new KValueColTextExport( HC, Data.data(), CoordRange ); + if( TC ) + { + if( HC ) Columns[NoOfCol++] = new KBorderColTextExport(); + Columns[NoOfCol++] = new KCharColTextExport( TC, Data.data(), CoordRange, CodecName ); + } + } +} + + +KBufferDrag::~KBufferDrag() +{ + for( uint i=0; i<NoOfCol; ++i ) + delete Columns[i]; +} + + + +void KBufferDrag::setData( const QByteArray &D ) +{ + Data = D; +} + + +const char *KBufferDrag::format( int i ) const +{ + return( i == 0 ? OctetStream : + i == 1 ? TextPlainUTF8 : + i == 2 ? TextPlain : + i == 3 ? localTextPlain() : + 0 ); +} + + +QByteArray KBufferDrag::encodedData( const char *Format ) const +{ + if( Format != 0 ) + { + // octet stream wanted? + if( qstrcmp(Format,OctetStream) == 0 ) + return( Data ); + + // plain text wanted? + if( qstrncmp(Format,TextPlain,10) == 0 ) + { + QCString Output; + QTextCodec *TextCodec = codecForCharset( QCString(Format).lower() ); + if( TextCodec == 0 ) + return Output; + + QString Text; + // plain copy? + if( NoOfCol == 0 ) + { + // duplicate the data and substitute all non-printable items with a space + KCharCodec *CharCodec = KCharCodec::createCodec( CodecName ); + static const QChar Tab('\t'); + static const QChar Return('\n'); + uint Size = Data.size(); + Text.setLength( Size ); + + for( uint i=0; i<Size; ++i ) + { + KHEChar B = CharCodec->decode( Data[i] ); + + Text.at(i) = B.isUndefined() ? KHEChar(UndefinedChar) : + (!B.isPrint() && B != Tab && B != Return ) ? KHEChar(SubstituteChar) : B; + } + // clean up + delete CharCodec; + } + // formatted copy + else + { + // initialize: one for the line's newline \n + uint NeededChars = 1; + for( uint i=0; i<NoOfCol; ++i ) + NeededChars += Columns[i]->charsPerLine(); + // scale with the number of lines + NeededChars *= CoordRange.lines(); + // find out needed size + Text.reserve( NeededChars ); + + // now fill + int l = CoordRange.start().line(); + for( uint i=0; i<NoOfCol; ++i ) + Columns[i]->printFirstLine( Text, l ); + Text.append('\n'); + for( ++l; l<=CoordRange.end().line(); ++l ) + { + for( uint i=0; i<NoOfCol; ++i ) + Columns[i]->printNextLine( Text ); + Text.append('\n'); + } + } + // generate the ouput + Output = TextCodec->fromUnicode( Text ); + // fix end + //if( TextCodec->mibEnum() != 1000 ) + //{ + // Don't include NUL in size (QCString::resize() adds NUL) + // ((QByteArray&)Output).resize( Output.length() ); + //} + return Output; + } + } + + // return empty dummy + return QByteArray(); +} + + + +bool KBufferDrag::canDecode( const QMimeSource* Source ) +{ + bool c =( Source->provides(OctetStream) /*|| Source->provides(TextPlain)*/ ); + return c; +// return( Source->provides(OctetStream) /*|| Source->provides(TextPlain)*/ ); +} + + +bool KBufferDrag::decode( const QMimeSource* Source, QByteArray &Dest ) +{ +// Dest = Source->encodedData( MediaString ); +// return Dest.size() != 0; + + bool CanDecode = Source->provides( OctetStream ); + if( CanDecode ) + Dest = Source->encodedData( OctetStream ); + + return CanDecode; +} + +#include "kbufferdrag.moc" diff --git a/khexedit/lib/kbufferdrag.h b/khexedit/lib/kbufferdrag.h new file mode 100644 index 0000000..86c498f --- /dev/null +++ b/khexedit/lib/kbufferdrag.h @@ -0,0 +1,76 @@ +/*************************************************************************** + kbufferdrag.h - description + ------------------- + begin : Mon Jul 07 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBUFFERDRAG_H +#define KHE_KBUFFERDRAG_H + +// qt specific +#include <qdragobject.h> +// lib specific +#include "khe.h" +#include "kcoordrange.h" +#include "kcoltextexport.h" + +namespace KHE +{ + +// class KBorderColumn; +class KOffsetColumn; +class KValueColumn; +class KCharColumn; + +typedef KColTextExport* KColTextExportPtr; +/** + *@author Friedrich W. H. Kossebau + */ +class KBufferDrag : public QDragObject +{ + Q_OBJECT + + public: + // TODO: make this call somewhat more generic + KBufferDrag( const QByteArray &, KCoordRange Range, + const KOffsetColumn *OC, const KValueColumn *HC, const KCharColumn *TC, + QChar SC, QChar UC, const QString &CN, + QWidget *Source = 0, const char *Name = 0 ); + ~KBufferDrag(); + + public: // QDragObject API + virtual const char *format( int i ) const; + virtual QByteArray encodedData( const char* ) const; + + public: + virtual void setData( const QByteArray &); + + public: + static bool canDecode( const QMimeSource* Source ); + static bool decode( const QMimeSource* Source, QByteArray &Dest ); + + protected: + QByteArray Data; + KCoordRange CoordRange; + /** collection of all the columns. All columns will be autodeleted. */ + KColTextExportPtr Columns[5]; + uint NoOfCol; + QChar SubstituteChar; + QChar UndefinedChar; + const QString &CodecName; +}; + +} + +#endif diff --git a/khexedit/lib/kbufferlayout.cpp b/khexedit/lib/kbufferlayout.cpp new file mode 100644 index 0000000..a2ea9a0 --- /dev/null +++ b/khexedit/lib/kbufferlayout.cpp @@ -0,0 +1,240 @@ +/*************************************************************************** + kbufferlayout.cpp - description + ------------------- + begin : Thu Jun 12 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#include "kbufferlayout.h" + +using namespace KHE; + + + +KBufferLayout::KBufferLayout( int NoBpL, int SO, int L ) + : NoOfBytesPerLine( NoBpL ), + StartOffset( SO ), + Length( L ) +{ + calcStart(); + calcEnd(); +} + + +KBufferLayout::~KBufferLayout() +{ +} + + +bool KBufferLayout::setStartOffset( int SO ) +{ + // rejecting <0 + if( SO < 0 ) + SO = 0; + + if( StartOffset == SO ) + return false; + + StartOffset = SO; + + calcStart(); + calcEnd(); + return true; +} + + +bool KBufferLayout::setNoOfBytesPerLine( int N ) +{ + // rejecting <1 + if( N < 1 ) + N = 1; + + // no changes? + if( NoOfBytesPerLine == N ) + return false; + + NoOfBytesPerLine = N; + + calcStart(); + calcEnd(); + return true; +} + + +bool KBufferLayout::setLength( int L ) +{ + // rejecting < 0 + if( L < 0 ) + L = 0; + + // no changes? + if( Length == L ) + return false; + + Length = L; + + calcEnd(); + return true; +} + + +void KBufferLayout::setNoOfLinesPerPage( int N ) +{ + NoOfLinesPerPage = N; +} + + +void KBufferLayout::calcStart() +{ + ContentCoords.setStart( KBufferCoord(StartOffset,NoOfBytesPerLine,false) ); +} + + +void KBufferLayout::calcEnd() +{ + ContentCoords.setEnd( (Length>0)?KBufferCoord(Length-1+StartOffset,NoOfBytesPerLine,false): + KBufferCoord(-1,ContentCoords.start().line()) ); +} + + +int KBufferLayout::indexAtCLineStart( int L ) const +{ + return ( L <= ContentCoords.start().line() ) ? 0: + ( L > ContentCoords.end().line() ) ? Length-1: + L * NoOfBytesPerLine - StartOffset; +} + + +int KBufferLayout::indexAtCLineEnd( int L ) const +{ + return ( L < ContentCoords.start().line() ) ? 0: + ( L >= ContentCoords.end().line() ) ? Length-1: + (L+1)*NoOfBytesPerLine-StartOffset-1; +} + + +int KBufferLayout::indexAtCCoord( const KBufferCoord &C ) const +{ + int Index = indexAtCoord( C ); + + return ( Index <= 0 ) ? 0: + ( Index >= Length ) ? Length-1: + Index; +} + + +int KBufferLayout::lineAtCIndex( int Index ) const +{ + return ( Index <= 0 ) ? ContentCoords.start().line(): + ( Index >= Length ) ? ContentCoords.end().line(): + lineAtIndex(Index); +} + + +KBufferCoord KBufferLayout::coordOfCIndex( int Index ) const +{ + return ( Index <= 0 ) ? ContentCoords.start(): + ( Index >= Length ) ? ContentCoords.end(): + coordOfIndex(Index); +} + + +int KBufferLayout::indexAtLineStart( int L ) const +{ + return ( L == ContentCoords.start().line() ) ? 0 : L*NoOfBytesPerLine-StartOffset; +} + + +int KBufferLayout::indexAtLineEnd( int L ) const +{ + return ( L == ContentCoords.end().line() ) ? Length-1 : (L+1)*NoOfBytesPerLine-StartOffset-1; +} + + +int KBufferLayout::indexAtCoord( const KBufferCoord &C ) const +{ + return C.indexByLineWidth( NoOfBytesPerLine ) - StartOffset; +} + +int KBufferLayout::lineAtIndex( int Index ) const +{ + return (Index+StartOffset)/NoOfBytesPerLine; +} + +KBufferCoord KBufferLayout::coordOfIndex( int Index ) const +{ + return KBufferCoord( Index+StartOffset, NoOfBytesPerLine, false ); +} + + + +int KBufferLayout::correctIndex( int I ) const +{ + return ( I <= 0 ) ? 0: + ( I >= Length ) ? Length-1: + I; +} + + +KBufferCoord KBufferLayout::correctCoord( const KBufferCoord &C ) const +{ + return ( C <= ContentCoords.start() ) ? ContentCoords.start(): + ( C >= ContentCoords.end() ) ? ContentCoords.end(): + ( C.pos() >= NoOfBytesPerLine ) ? KBufferCoord( NoOfBytesPerLine-1, C.line() ): + C; +} + + +bool KBufferLayout::atLineStart( const KBufferCoord &C ) const +{ + return ( C.line() == ContentCoords.start().line() ) ? C.pos() == ContentCoords.start().pos(): + C.pos() == 0; +} + +bool KBufferLayout::atLineEnd( const KBufferCoord &C ) const +{ + return ( C.line() == ContentCoords.end().line() ) ? C.pos() == ContentCoords.end().pos(): + C.pos() == NoOfBytesPerLine-1; +} + + +KSection KBufferLayout::positions( int Line ) const +{ + return KSection( firstPos(Line), lastPos(Line) ); +} + + +int KBufferLayout::firstPos( const KBufferCoord &C ) const +{ + return ( ContentCoords.start().isLaterInLineThan(C) ) ? ContentCoords.start().pos() : C.pos(); +} + +int KBufferLayout::lastPos( const KBufferCoord &C ) const +{ + return ( ContentCoords.end().isPriorInLineThan(C) ) ? ContentCoords.end().pos() : C.pos(); +} + +int KBufferLayout::firstPos( int Line ) const +{ + return Line == ContentCoords.start().line() ? ContentCoords.start().pos() : 0; +} + +int KBufferLayout::lastPos( int Line ) const +{ + return ( Line == ContentCoords.end().line() ) ? ContentCoords.end().pos() : NoOfBytesPerLine-1; +} + +bool KBufferLayout::hasContent( int Line ) const +{ + return ContentCoords.includesLine( Line ); +} diff --git a/khexedit/lib/kbufferlayout.h b/khexedit/lib/kbufferlayout.h new file mode 100644 index 0000000..c243225 --- /dev/null +++ b/khexedit/lib/kbufferlayout.h @@ -0,0 +1,196 @@ +/*************************************************************************** + kbufferlayout.h - description + ------------------- + begin : Thu Jun 12 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBUFFERLAYOUT_H +#define KHE_KBUFFERLAYOUT_H + +// lib specific +#include "kcoordrange.h" +#include "ksection.h" + +namespace KHE { + +/**@short the logical layout of a plain buffer view + * + * Given the values for + * * length of the buffer, + * * number of bytes per line, + * * a possible (relative) offset in the display, and + * * the number of lines per page jump + * the following values are calculated: + * * starting line of display, + * * starting position in this line, + * * final line of display, + * * final position in this line, and + * * the total number of lines (is final line +1 or 0) + * + * This layout sees the buffer as a continous stream of byte, + * thus uses each line after the start from the begin to the end. + * + * If the buffer is empty the end coord will be set one pos left to the start coord + * to easen the cursor handling. + * + *@author Friedrich W. H. Kossebau + */ +class KBufferLayout +{ + public: + KBufferLayout( int NoBpL, int SO, int L ); + //KBufferLayout(); + ~KBufferLayout(); + + + public: // given values + /** */ + int startOffset() const; + /** returns number of bytes per line */ + int noOfBytesPerLine() const; + /** returns the length of the displayed data (equals Buffer->size()) */ + int length() const; + /** returns number of lines per visual page */ + int noOfLinesPerPage() const; + + public: // calculated values + int startLine() const; + int startPos() const; + /** returns the coord of the start */ + KBufferCoord start() const; + + int finalLine() const; + int finalPos() const; + /** returns the coord of the end */ + KBufferCoord final() const; + + /** tells how much lines this layout needs (incl. blank leading lines due to StartOffset) */ + int noOfLines() const; + + + public: // value calculation service + /** calculates the index of the coord + * If the coord is before the first coord the first index is returned, + * if the coord is behind the last coord the last index is returned + */ + int indexAtCCoord( const KBufferCoord &C ) const; + /** calculates the index of the first pos in line. + * If the line is below the first line the first index is returned, + * if the line is above the last line the last index is returned + */ + int indexAtCLineStart( int L ) const; + /** calculates the index of last pos in line + * If the line is below the first line the first index is returned, + * if the line is above the last line the last index is returned + */ + int indexAtCLineEnd( int L ) const; + /** calculates the line in which index is found + * If the index is below the first index the first line is returned, + * if the index is above the last index the last line is returned + */ + int lineAtCIndex( int Index ) const; + /** calculates the coord in which index is found + * If the index is below the first index the first coord is returned, + * if the index is above the last index the last coord is returned + */ + KBufferCoord coordOfCIndex( int Index ) const; + + /** calculates the index of coord. if coord is invalid the behaviour is undefinded */ + int indexAtCoord( const KBufferCoord &C ) const; + /** calculates the index of the first pos in line. if line is invalid the behaviour is undefinded */ + int indexAtLineStart( int L ) const; + /** calculates the index of last pos in line. if line is invalid the behaviour is undefinded */ + int indexAtLineEnd( int L ) const; + /** calculates the line in which index is found. if index is invalid the behaviour is undefinded */ + int lineAtIndex( int Index ) const; + /** calculates the coord in which index is found. if index is invalid the behaviour is undefinded */ + KBufferCoord coordOfIndex( int Index ) const; + + /** returns the used positions in line */ + KSection positions( int Line ) const; + /** returns the first Pos in line. if line is invalid the behaviour is undefinded */ + int firstPos( int Line ) const; + /** returns the last Pos in line. if line is invalid the behaviour is undefinded */ + int lastPos( int Line ) const; + /** returns the valid Pos or the first Pos in line. if coord is invalid the behaviour is undefinded */ + int firstPos( const KBufferCoord &C ) const; + /** returns the valid Pos or the last Pos in line. if coord is invalid the behaviour is undefinded */ + int lastPos( const KBufferCoord &C ) const; + /** returns true if the line has content */ + bool hasContent( int Line ) const; + /** returns true if the coord is the first in it's line. if coord is invalid the behaviour is undefinded */ + bool atLineStart( const KBufferCoord &C ) const; + /** returns true if the coord is the last in it's line. if coord is invalid the behaviour is undefinded */ + bool atLineEnd( const KBufferCoord &C ) const; + + /** returns the index if valid or the nearest valid index */ + int correctIndex( int I ) const; + /** returns the coord if valid or the nearest valid coord */ + KBufferCoord correctCoord( const KBufferCoord &C ) const; + + + public: // modification access; return true if changes + /** sets StartOffset, returns true if changed */ + bool setStartOffset( int SO ); + /** sets number of bytes per line, returns true if changed */ + bool setNoOfBytesPerLine( int N ); + /** sets number of lines per page */ + void setNoOfLinesPerPage( int N ); + /** sets length of data to display, returns true if changed */ + bool setLength( int L ); + + + protected: + /** calculates the start coord by startoffset and number of bytes per line */ + void calcStart(); + /** calculates the final coord by startoffset, length, and number of bytes per line */ + void calcEnd(); + + + protected: + /** how many chars per line */ + int NoOfBytesPerLine; + /** starting offset of the displayed data */ + int StartOffset; + /** length of the displayed buffer */ + int Length; + /** number of lines that are moved by page up/down */ + int NoOfLinesPerPage; + + protected: // calculated values, buffered + /** coord in which the start offset is (starting with 0) */ +// KBufferCoord Start; + /** coord in which the last byte is (starting with 0) */ +// KBufferCoord Final; + /** */ + KCoordRange ContentCoords; +}; + + +inline int KBufferLayout::startOffset() const { return StartOffset; } +inline int KBufferLayout::noOfBytesPerLine() const { return NoOfBytesPerLine; } +inline int KBufferLayout::length() const { return Length; } + +inline KBufferCoord KBufferLayout::final() const { return ContentCoords.end(); } +inline KBufferCoord KBufferLayout::start() const { return ContentCoords.start(); } +inline int KBufferLayout::startPos() const { return start().pos(); } +inline int KBufferLayout::finalPos() const { return final().pos(); } +inline int KBufferLayout::startLine() const { return start().line(); } +inline int KBufferLayout::finalLine() const { return final().line(); } +inline int KBufferLayout::noOfLinesPerPage() const { return NoOfLinesPerPage; } +inline int KBufferLayout::noOfLines() const { return Length==0?0:final().line()+1; } + +} + +#endif diff --git a/khexedit/lib/kbufferranges.cpp b/khexedit/lib/kbufferranges.cpp new file mode 100644 index 0000000..57fb9c4 --- /dev/null +++ b/khexedit/lib/kbufferranges.cpp @@ -0,0 +1,307 @@ +/*************************************************************************** + kbufferranges.cpp - description + ------------------- + begin : Sun Jun 22 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +//#include <kdebug.h> + +// lib specific +#include "kbufferranges.h" + + +using namespace KHE; + +KBufferRanges::KBufferRanges( KBufferLayout *L ) + : Modified( false ), + Layout( L ) +{ +} + + +KBufferRanges::~KBufferRanges() +{ +} + + +void KBufferRanges::reset() +{ + Selection.cancel(); + FirstWordSelection.unset(); + Marking.unset(); + ChangedRanges.clear(); +} + + +void KBufferRanges::setMarking( KSection M ) +{ + if( Marking == M ) + return; + + Marking = M; + addChangedRange( M ); +} + + +void KBufferRanges::removeFurtherSelections() +{ + for( int i = 1; i < noOfSelections(); ++i ) + removeSelection( i ); +} + + +void KBufferRanges::setSelection( KSection S ) +{ + bool Changed = Selection.isValid(); + if( Changed ) + addChangedRange( Selection ); + Selection = S; + addChangedRange( Selection ); +} + +void KBufferRanges::setSelectionStart( int StartIndex ) +{ + bool Changed = Selection.isValid(); + if( Changed ) + addChangedRange( Selection ); + + Selection.setStart( StartIndex ); +} + + +void KBufferRanges::setSelectionEnd( int EndIndex ) +{ + KSection OldSelection = Selection; + Selection.setEnd( EndIndex ); + + // TODO: think about rather building a diff of the sections + if( !OldSelection.isValid() ) + { + addChangedRange( Selection ); + return; + } + if( !Selection.isValid() ) + { + addChangedRange( OldSelection ); + return; + } + + if( OldSelection == Selection ) + return; + int CS_; + int CE_; + // changes at the end? + if( Selection.start() == OldSelection.start() ) + { + CS_ = OldSelection.end()+1; + CE_ = Selection.end(); + if( CE_ < CS_ ) + { + CS_ = Selection.end()+1; + CE_ = OldSelection.end(); + } + } + // changes at the start? + else if( Selection.end() == OldSelection.end() ) + { + CS_ = OldSelection.start(); + CE_ = Selection.start()-1; + if( CE_ < CS_ ) + { + CS_ = Selection.start(); + CE_ = OldSelection.start()-1; + } + } + // change over the anchor + else + { + CS_ = OldSelection.start(); + CE_ = Selection.end(); + if( CE_ < CS_ ) + { + CS_ = Selection.start(); + CE_ = OldSelection.end(); + } + } + KSection C( CS_, CE_ ); + + bool Changed = C.isValid(); + if( Changed ) + addChangedRange( C ); + return; +} + + +void KBufferRanges::removeSelection( int id ) +{ + if( id > 0 ) + return; + + bool Changed = Selection.isValid(); + if( Changed ) + addChangedRange( Selection ); + + Selection.cancel(); + FirstWordSelection.unset(); +} + + +bool KBufferRanges::overlapsSelection( int FirstIndex, int LastIndex, int *SI, int *EI ) const +{ + if( Selection.overlaps(KSection(FirstIndex,LastIndex)) ) + { + *SI = Selection.start(); + *EI = Selection.end(); + return true; + } + return false; +} + + +bool KBufferRanges::overlapsMarking( int FirstIndex, int LastIndex, int *SI, int *EI ) const +{ + if( Marking.overlaps(KSection(FirstIndex,LastIndex)) ) + { + *SI = Marking.start(); + *EI = Marking.end(); + return true; + } + return false; +} + + +const KSection *KBufferRanges::firstOverlappingSelection( KSection Range ) const +{ + if( Selection.overlaps(Range) ) + return &Selection; + + return 0L; +} + + +const KSection *KBufferRanges::overlappingMarking( KSection Range ) const +{ + if( Marking.overlaps(Range) ) + return &Marking; + + return 0L; +} + +/* +bool KBufferRanges::overlapsChanges( int FirstIndex, int LastIndex, int *SI, int *EI ) const +{ + for( KCoordRangeList::const_iterator S=ChangedRanges.begin(); S!=ChangedRanges.end(); ++S ) + { + if( (*S).overlaps(KBuff(FirstIndex,LastIndex)) ) + { + *SI = (*S).start(); + *EI = (*S).end(); + return true; + } + } + + return false; +} + +bool KBufferRanges::overlapsChanges( KSection Indizes, KSection *ChangedRange ) const +{ + for( KSectionList::const_iterator S=ChangedRanges.begin(); S!=ChangedRanges.end(); ++S ) + { + if( (*S).overlaps(Indizes) ) + { + *ChangedRange = *S; + return true; + } + } + + return false; +} +*/ +bool KBufferRanges::overlapsChanges( const KCoordRange &Range, KCoordRange *ChangedRange ) const +{ + // TODO: add a lastusedrange pointer for quicker access + for( KCoordRangeList::const_iterator R=ChangedRanges.begin(); R!=ChangedRanges.end(); ++R ) + { + if( (*R).overlaps(Range) ) + { + *ChangedRange = *R; + return true; + } + } + + return false; +} + + +void KBufferRanges::addChangedRange( int SI, int EI ) +{ + addChangedRange( KSection(SI,EI) ); +} + + +void KBufferRanges::addChangedRange( KSection S ) +{ + addChangedRange( KCoordRange(Layout->coordOfIndex(S.start()),Layout->coordOfIndex(S.end())) ); +} + + +void KBufferRanges::addChangedRange( const KCoordRange &NewRange ) +{ + ChangedRanges.addCoordRange( NewRange ); + + Modified = true; +} + + +void KBufferRanges::removeMarking() +{ + bool Changed = Marking.isValid(); + if( Changed ) + addChangedRange( Marking ); + + Marking.unset(); +} + + +void KBufferRanges::resetChangedRanges() +{ + ChangedRanges.clear(); + Modified = false; +} + + +void KBufferRanges::setFirstWordSelection( KSection Section ) +{ + FirstWordSelection = Section; + setSelection( FirstWordSelection ); +} + + void KBufferRanges::ensureWordSelectionForward( bool Forward ) + { + // in the anchor not on the right side? + if( Selection.isForward() != Forward ) + { + if( Forward ) + { + setSelectionEnd( FirstWordSelection.start() ); + Selection.setForward(); + } + else + { + setSelectionEnd( FirstWordSelection.end()+1 ); + Selection.setBackward(); + } + } + } + diff --git a/khexedit/lib/kbufferranges.h b/khexedit/lib/kbufferranges.h new file mode 100644 index 0000000..ed2cbce --- /dev/null +++ b/khexedit/lib/kbufferranges.h @@ -0,0 +1,130 @@ +/*************************************************************************** + kbufferranges.h - description + ------------------- + begin : Sun Jun 22 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBUFFERRANGES_H +#define KHE_KBUFFERRANGES_H + +// lib specific +#include "kbufferlayout.h" +#include "kselection.h" +#include "ksectionlist.h" +#include "kcoordrangelist.h" + +namespace KHE +{ + +/** a class to control all the ranges like marking and selections + * holds also all modified ranges and merges them so a repaint can take its info from here + * + * @author Friedrich W. H. Kossebau + */ +class KBufferRanges +{ + public: + KBufferRanges( KBufferLayout *L ); + ~KBufferRanges(); + + public: // modifcation access + void setMarking( KSection M ); + void setSelectionStart( int StartIndex ); + void setSelectionEnd( int StartIndex ); + void setSelection( KSection S ); + /** */ + void setFirstWordSelection( KSection S ); + /** */ + void ensureWordSelectionForward( bool Forward ); + + /** removes marking and returns true if something changed */ + void removeMarking(); + /** removes selection with id and returns true if something changed */ + void removeSelection( int id = 0 ); + /** removes all but the standard selection and returns true if something changed */ + void removeFurtherSelections(); + + void addChangedRange( KSection S ); + void addChangedRange( int SI, int EI ); + void addChangedRange( const KCoordRange &NewRange ); + void resetChangedRanges(); + + void setModified( bool M = true ); + /** removes all ranges */ + void reset(); + + public: // value access + int noOfSelections() const; + int selectionStart() const; + int selectionEnd() const; + KSection selection() const; + KSection firstWordSelection() const; + int selectionLength() const; + bool isModified() const; + + public: // calculated logic access + bool hasSelection() const; + bool hasMarking() const; + bool selectionStarted() const; + bool selectionJustStarted() const; + bool hasFirstWordSelection() const; + bool selectionIncludes( int Index ) const; + bool markingIncludes( int Index ) const; + // TODO: next three are deprecated + bool overlapsSelection( int FirstIndex, int LastIndex, int *SI, int *EI ) const; + bool overlapsMarking( int FirstIndex, int LastIndex, int *SI, int *EI ) const; +// bool overlapsChanges( int FirstIndex, int LastIndex, int *SI, int *EI ) const; +// bool overlapsChanges( KSection Indizes, KSection *ChangedRange ) const; + bool overlapsChanges( const KCoordRange &Range, KCoordRange *ChangedRange ) const; + const KSection *firstOverlappingSelection( KSection Range ) const; + const KSection *overlappingMarking( KSection Range ) const; + + + protected: + /** true if something changed */ + bool Modified; + + KSection Marking; + KSelection Selection; + /** memories first selected word on wordwise selection */ + KSection FirstWordSelection; + + KCoordRangeList ChangedRanges; + + KBufferLayout *Layout; +}; + + +inline int KBufferRanges::noOfSelections() const { return 1; } + +inline int KBufferRanges::selectionStart() const { return Selection.start(); } +inline int KBufferRanges::selectionEnd() const { return Selection.end(); } +inline KSection KBufferRanges::selection() const { return Selection; } +inline KSection KBufferRanges::firstWordSelection() const { return FirstWordSelection; } +inline int KBufferRanges::selectionLength() const { return Selection.width(); } +inline bool KBufferRanges::isModified() const { return Modified; } + +inline bool KBufferRanges::hasSelection() const { return Selection.isValid(); } +inline bool KBufferRanges::selectionStarted() const { return Selection.started(); } +inline bool KBufferRanges::selectionJustStarted() const { return Selection.justStarted(); } +inline bool KBufferRanges::hasFirstWordSelection() const { return FirstWordSelection.isValid(); } +inline bool KBufferRanges::hasMarking() const { return Marking.isValid(); } +inline bool KBufferRanges::selectionIncludes( int Index ) const { return Selection.includes( Index ); } +inline bool KBufferRanges::markingIncludes( int Index ) const { return Marking.includes( Index ); } + +inline void KBufferRanges::setModified( bool M ) { Modified = M; } + +} + +#endif diff --git a/khexedit/lib/kbytecodec.h b/khexedit/lib/kbytecodec.h new file mode 100644 index 0000000..fc4e1b3 --- /dev/null +++ b/khexedit/lib/kbytecodec.h @@ -0,0 +1,73 @@ +/*************************************************************************** + kbytecodec.h - description + ------------------- + begin : Sam Mai 17 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBYTECODEC_H +#define KHE_KBYTECODEC_H + +#include "khe.h" +#include <qstring.h> + +namespace KHE +{ + +/** class that is able to convert codings to and from + * hexadecimal, decimal, octal, and binary + * + * the buffer will be always filled up to CodingWidth, if not using shortCodingFunction + * a closing '\0' will be always added + * + *@author Friedrich W. H. Kossebau + */ + +class KByteCodec +{ + public: + static KByteCodec *createCodec( KCoding C ); + + + protected: // hiding, as this class should never be instanciated + KByteCodec() {} + + public: // API to be implemented + /** */ + virtual unsigned int encodingWidth() const = 0; + /** */ + virtual unsigned char digitsFilledLimit() const = 0; + + /** encodes the Char and writes the result to */ + virtual void encode( QString &Digits, unsigned int Pos, const unsigned char Char ) const = 0; + /** */ + virtual void encodeShort( QString &Digits, unsigned int Pos, const unsigned char Char ) const = 0; + + /** */ + virtual bool appendDigit( unsigned char *Byte, const unsigned char Digit ) const = 0; + /** */ + virtual void removeLastDigit( unsigned char *Byte ) const = 0; + /** */ + virtual bool isValidDigit( const unsigned char Digit ) const = 0; + /** */ + virtual bool turnToValue( unsigned char *Digit ) const = 0; + + + public: + /** */ + uint decode( unsigned char *Char, const QString &Digits, uint Pos ) const; +}; + +} + +#endif diff --git a/khexedit/lib/kbytesedit.cpp b/khexedit/lib/kbytesedit.cpp new file mode 100644 index 0000000..40b57a1 --- /dev/null +++ b/khexedit/lib/kbytesedit.cpp @@ -0,0 +1,162 @@ +/*************************************************************************** + kbytesedit.cpp - description + ------------------- + begin : Die Jul 9 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "kplainbuffer.h" +#include "kbytesedit.h" +#include "kbufferranges.h" +#include "kbuffercursor.h" + +using namespace KHE; + + +KBytesEdit::KBytesEdit( char *D, int DS_, int RS_, bool KM, QWidget *Parent, const char *Name, WFlags F ) + : KHexEdit( 0L, Parent, Name, F ), + AutoDelete( false ) +{ + setData( D, DS_, RS_, KM ); +} + +KBytesEdit::KBytesEdit( char *D, int DS_, QWidget *Parent, const char *Name, WFlags F ) + : KHexEdit( 0L, Parent, Name, F ), + AutoDelete( false ) +{ + setData( D, DS_ ); +} + + +KBytesEdit::KBytesEdit( QWidget *Parent, const char *Name, WFlags F ) + : KHexEdit( 0L, Parent, Name, F ), + AutoDelete( false ) +{ + setDataBuffer( new KPlainBuffer() ); +} + +KBytesEdit::~KBytesEdit() +{ + clean(); +} + +void KBytesEdit::setReadOnly( bool RO ) +{ + KPlainBuffer *Buffer = dynamic_cast<KPlainBuffer *>(DataBuffer); + if( Buffer ) + Buffer->setReadOnly( RO ); + KHexEdit::setReadOnly( RO ); +} + + +void KBytesEdit::setAutoDelete( bool AD ) +{ + AutoDelete = AD; +} + + +char *KBytesEdit::data() const +{ + KPlainBuffer *Buffer = dynamic_cast<KPlainBuffer *>(DataBuffer); + return Buffer ? Buffer->data() : 0L; +} + + +void KBytesEdit::setData( char *D, int S, int RS_, bool KM ) +{ + KPlainBuffer *NewBuffer = new KPlainBuffer( D, S, RS_, KM ); + if( DataBuffer ) + { + // take the settings + NewBuffer->setReadOnly( DataBuffer->isReadOnly() ); + clean(); + } + else + NewBuffer->setReadOnly( isReadOnly() ); + + setDataBuffer( NewBuffer ); +} + + +int KBytesEdit::dataSize() const +{ + KPlainBuffer *Buffer = dynamic_cast<KPlainBuffer *>(DataBuffer); + return Buffer ? Buffer->size() : -1; +} + + +int KBytesEdit::maxDataSize() const +{ + KPlainBuffer *Buffer = dynamic_cast<KPlainBuffer *>(DataBuffer); + return Buffer ? Buffer->maxSize() : -1; +} + + +void KBytesEdit::setMaxDataSize( int MS ) +{ + KPlainBuffer *Buffer = dynamic_cast<KPlainBuffer *>(DataBuffer); + if( Buffer ) + Buffer->setMaxSize( MS ); +} + + +bool KBytesEdit::keepsMemory() const +{ + KPlainBuffer *Buffer = dynamic_cast<KPlainBuffer *>(DataBuffer); + return Buffer ? Buffer->keepsMemory() : false; +} + + +void KBytesEdit::setKeepsMemory( bool KM ) +{ + KPlainBuffer *Buffer = dynamic_cast<KPlainBuffer *>(DataBuffer); + if( Buffer ) + Buffer->setKeepsMemory( KM ); +} + + +bool KBytesEdit::isAutoDelete() const { return AutoDelete; } + + +void KBytesEdit::repaintRange( int i1, int i2 ) +{ + bool ChangeCursor = !(CursorPaused) && KSection(i1,i2).includes( BufferCursor->index() ); + if( ChangeCursor ) + pauseCursor(); + + BufferRanges->addChangedRange( i1, i2 ); + + repaintChanged(); + + if( ChangeCursor ) + unpauseCursor(); +} + + +void KBytesEdit::clean() +{ + if( DataBuffer ) + { + if( AutoDelete ) + { + char *D = data(); + if( D ) + delete [] D; + } + delete DataBuffer; + } +} + + +#include "kbytesedit.moc" diff --git a/khexedit/lib/kbytesedit.h b/khexedit/lib/kbytesedit.h new file mode 100644 index 0000000..daf8b6e --- /dev/null +++ b/khexedit/lib/kbytesedit.h @@ -0,0 +1,163 @@ +/*************************************************************************** + kbytesedit.h - description + ------------------- + begin : Die Jul 9 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KBYTESEDIT_H +#define KHE_KBYTESEDIT_H + + +#include "khexedit.h" + +#include <khexedit_export.h> + +namespace KHE +{ + +class KDataBuffer; +class KBytesEditPrivate; + +/** the beginner's hex edit widget ;) + * + * It hides the concept of the KDataBuffer and accepts a pure pointer + * to a reasonable large array of bytes + * + * 1. used as viewer + * a) static data ranges -> no changes for data pointer and length + * possible changes are told to the widget by repaintRange + * b) changing data ranges -> data pointer and length might change + * changes told by + * * resetData( char *, int size, bool repaint ); + * * + * 2. used as editor + * a) static data ranges + * data pointer stays the same + * b) changing data ranges + * pointer to the data changes in charge of the widget: + * given pointer and intermediate pointer are possibly invalid + * problem: who cares about the array if the data is deleted? + * -> solved by setAutoDelete() + * + * + *@author Friedrich W. H. Kossebau + */ +//TODO: give the bytes edit widget an empty buffer as default +class KHEXEDIT_EXPORT KBytesEdit : public KHexEdit +{ + Q_OBJECT + //_PROPERTY( char * Data READ data ) + Q_PROPERTY( int DataSize READ dataSize ) + Q_PROPERTY( int MaxDataSize READ maxDataSize WRITE setMaxDataSize ) + Q_PROPERTY( bool AutoDelete READ isAutoDelete WRITE setAutoDelete DESIGNABLE false ) + + + public: + /** creates a new widget to view/edit data + * @param D pointer to memory + * @param S size of used memory + * @param RS_ real size of the memory + * @param KM keep the memory on resize (RS_ is then the maximum size) + * @param Parent parent widget + * @param Name name for this widget + * @param F flags + */ + KBytesEdit( char *D, int DS_, int RS_, bool KM, QWidget *Parent = 0, const char *Name = 0, WFlags F = 0 ); + /** hands over to the editor a new byte array. + * If there exists an old one and autodelete is set the old one gets deleted. + * @param D pointer to memory + * @param S size of used memory + * @param RS_ real size of the memory + * @param KM keep the memory on resize (RS_ is the maximum size) + */ + KBytesEdit( char *D, int DS_, QWidget *Parent = 0, const char *Name = 0, WFlags F = 0 ); + /** hands over to the editor a new byte array. + * If there exists an old one and autodelete is set the old one gets deleted. + * @param D pointer to memory + * @param S size of used memory + * @param RS_ real size of the memory + * @param KM keep the memory on resize (RS_ is the maximum size) + */ + KBytesEdit( QWidget *Parent = 0, const char *Name = 0, WFlags F = 0 ); + virtual ~KBytesEdit(); + + + public: // value access + /** returns the pointer to the actual byte array. This can be but must not be the one + * that was given in the constructor. + */ + char *data() const; + /** returns the size of the actual byte array */ + int dataSize() const; + /** returns the maximal allowed size for the byte array */ + int maxDataSize () const; + /** returns whether autodelete is set for the byte array */ + bool isAutoDelete() const; + /** returns whether the memory of the byte array is kept */ + bool keepsMemory() const; + + public: // logic value service + + public: // modification access + + public slots: + /** hands over to the editor a new byte array. + * If there exists an old one and autodelete is set the old one gets deleted. + * @param D pointer to memory + * @param S size of used memory + * @param RS_ real size of the memory + * @param KM keep the memory on resize (RS_ is the maximum size) + */ + void setData( char *D, int S, int RS_ = -1, bool KM = true ); + + /** sets whether the given array should be handled read only or not */ + virtual void setReadOnly( bool RO = true ); + /** sets the maximal size of the actual byte array. If the actual array is already larger + * it will not be modified but there can be only done non-inserting actions + * until the array's is below the limit + */ + void setMaxDataSize( int MS ); + /** sets whether the array should be deleted on the widget's end or if a new array is set. + * Default is false + */ + void setAutoDelete( bool AD = true ); + /** sets whether the memory given by setData or in the constructor should be kept on resize + */ + void setKeepsMemory( bool KM = true ); + + /** repaint the indizes from i1 to i2 */ + void repaintRange( int i1, int i2 ); + + protected: + /** deletes the databuffer */ + void clean(); + + + protected slots: + + + protected: + /** */ + bool AutoDelete:1; + /** */ + KBytesEditPrivate *d; + + private: // Disabling copy constructor and operator= - not useful + KBytesEdit( const KBytesEdit & ); + KBytesEdit &operator=( const KBytesEdit & ); +}; + +} + +#endif diff --git a/khexedit/lib/kcharcodec.h b/khexedit/lib/kcharcodec.h new file mode 100644 index 0000000..9d1b628 --- /dev/null +++ b/khexedit/lib/kcharcodec.h @@ -0,0 +1,55 @@ +/*************************************************************************** + kcharcodec.h - description + ------------------- + begin : Do Nov 25 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KCHARCODEC_H +#define KHE_KCHARCODEC_H + +// qt specific +#include <qstringlist.h> +// lib specific +#include "khe.h" +#include "khechar.h" +#include "khexedit_export.h" + + +namespace KHE +{ + +class KHEXEDIT_EXPORT KCharCodec +{ + public: + /** */ + static KCharCodec* createCodec( KEncoding E ); + /** */ + static KCharCodec* createCodec( const QString &Name ); + + static const QStringList &codecNames(); + + public: // API to be implemented + virtual KHEChar decode( char Byte ) const = 0; + virtual bool encode( char *D, const QChar &C ) const = 0; + virtual const QString& name() const = 0; + + protected: + /** */ + static QStringList CodecNames; +}; + +} + +#endif + diff --git a/khexedit/lib/kcharcoltextexport.cpp b/khexedit/lib/kcharcoltextexport.cpp new file mode 100644 index 0000000..bc4a60e --- /dev/null +++ b/khexedit/lib/kcharcoltextexport.cpp @@ -0,0 +1,71 @@ +/*************************************************************************** + kcharcoltextexport.cpp - description + ------------------- + begin : Wed Sep 03 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "kbufferlayout.h" +#include "kcharcolumn.h" +#include "kcharcodec.h" +#include "kcharcoltextexport.h" + +using namespace KHE; + + +KCharColTextExport::KCharColTextExport( const KCharColumn* TC, const char *D, KCoordRange CR, const QString &CodecName ) + : KBufferColTextExport( TC, D, CR, 1 ), + CharCodec( KCharCodec::createCodec(CodecName) ), + SubstituteChar( TC->substituteChar() ), + UndefinedChar( TC->undefinedChar() ) +{ +} + + +KCharColTextExport::~KCharColTextExport() +{ + delete CharCodec; +} + + +void KCharColTextExport::print( QString &T ) const +{ + int p = 0; + int pEnd = NoOfBytesPerLine; + // correct boundaries + if( PrintLine == CoordRange.start().line() ) + p = CoordRange.start().pos(); + if( PrintLine == CoordRange.end().line() ) + pEnd = CoordRange.end().pos()+1; + + // draw individual chars + uint e = 0; + for( ; p<pEnd; ++p, ++PrintData ) + { + // get next position + uint t = Pos[p]; + // clear spacing + T.append( whiteSpace(t-e) ); + + // print char + KHEChar B = CharCodec->decode( *PrintData ); + + T.append( B.isUndefined() ? KHEChar(UndefinedChar) : !B.isPrint() ? KHEChar(SubstituteChar) : B ); + e = t + 1; + } + + T.append( whiteSpace(NoOfCharsPerLine-e) ); + + ++PrintLine; +} diff --git a/khexedit/lib/kcharcoltextexport.h b/khexedit/lib/kcharcoltextexport.h new file mode 100644 index 0000000..05a570c --- /dev/null +++ b/khexedit/lib/kcharcoltextexport.h @@ -0,0 +1,50 @@ +/*************************************************************************** + kcharcoltextexport.h - description + ------------------- + begin : Wed Sep 3 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KCHARCOLTEXTEXPORT_H +#define KHE_KCHARCOLTEXTEXPORT_H + +// lib specific +#include "khe.h" +#include "kbuffercoltextexport.h" + + +namespace KHE +{ + +class KCharColumn; +class KCharCodec; + + +class KCharColTextExport : public KBufferColTextExport +{ + public: + KCharColTextExport( const KCharColumn* BF, const char *D, KCoordRange CR, const QString &CodecName ); + virtual ~KCharColTextExport(); + + protected: //API + virtual void print( QString &T ) const; + + protected: + KCharCodec *CharCodec; + QChar SubstituteChar; + QChar UndefinedChar; +}; + +} + +#endif diff --git a/khexedit/lib/kcharcolumn.cpp b/khexedit/lib/kcharcolumn.cpp new file mode 100644 index 0000000..9ecbd5a --- /dev/null +++ b/khexedit/lib/kcharcolumn.cpp @@ -0,0 +1,61 @@ +/*************************************************************************** + kcharcolumn.cpp - description + ------------------- + begin : Mit Sep 3 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// c specific +#include <ctype.h> +// qt specific +#include <qpainter.h> +// kde specific +#include <kcharsets.h> +#include <klocale.h> +#include <kglobal.h> +// lib specific +#include "kcolumnsview.h" +#include "kbuffercursor.h" +#include "kbufferlayout.h" +#include "kbufferranges.h" +#include "kcharcolumn.h" + +using namespace KHE; + +static const bool DefaultShowUnprintable = false; +static const QChar DefaultSubstituteChar = (char)'.'; +static const QChar DefaultUndefinedChar = (char)'?'; + + +KCharColumn::KCharColumn( KColumnsView *CV, KDataBuffer *B, KBufferLayout *L, KBufferRanges *R ) + : KBufferColumn( CV, B, L, R ), + ShowUnprintable( DefaultShowUnprintable ), + SubstituteChar( DefaultSubstituteChar ), + UndefinedChar( DefaultUndefinedChar ) +{ + setSpacing( 0, 0, 0 ); +} + + +KCharColumn::~KCharColumn() +{ +} + +void KCharColumn::drawByte( QPainter *P, char /*Byte*/, KHEChar B, const QColor &Color ) const +{ + // make a drawable String out of it + QString BS( B.isUndefined() ? KHEChar(UndefinedChar) : ( !(ShowUnprintable || B.isPrint()) ? KHEChar(SubstituteChar) : B )); + + P->setPen( Color ); + P->drawText( 0, DigitBaseLine, BS ); +} diff --git a/khexedit/lib/kcharcolumn.h b/khexedit/lib/kcharcolumn.h new file mode 100644 index 0000000..1e875b0 --- /dev/null +++ b/khexedit/lib/kcharcolumn.h @@ -0,0 +1,116 @@ +/*************************************************************************** + kcharcolumn.h - description + ------------------- + begin : Mit Sep 3 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KCHARCOLUMN_H +#define KHE_KCHARCOLUMN_H + +// qt specific +#include <qstring.h> +// lib specific +#include "kbuffercolumn.h" + +class QPainter; +class QColor; + + +namespace KHE +{ + + +/** buffer column that interprets the bytes as chars + * + *@author Friedrich W. H. Kossebau + */ +class KCharColumn : public KBufferColumn +{ + public: + KCharColumn( KColumnsView *CV, KDataBuffer *B, KBufferLayout *L, KBufferRanges *R ); + virtual ~KCharColumn(); + + + public: // modification access + /** sets whether "unprintable" chars (>32) should be displayed in the char column + * with their corresponding character. + * @param SU + * returns true if there was a change + */ + bool setShowUnprintable( bool SU = true ); + /** sets the substitute character for "unprintable" chars + * returns true if there was a change + */ + bool setSubstituteChar( QChar SC ); + /** sets the undefined character for "undefined" chars + * returns true if there was a change + */ + bool setUndefinedChar( QChar UC ); + + + public: // value access + /** returns true if "unprintable" chars (>32) are displayed in the char column + * with their corresponding character, default is false + */ + bool showUnprintable() const; + /** returns the actually used substitute character for "unprintable" chars, default is '.' */ + QChar substituteChar() const; + /** returns the actually used undefined character for "undefined" chars, default is '?' */ + QChar undefinedChar() const; + + + protected: // KBufferColumn API + virtual void drawByte( QPainter *P, char Byte, KHEChar B, const QColor &Color ) const; + + protected: + /** */ + bool ShowUnprintable; + /** */ + QChar SubstituteChar; + /** */ + QChar UndefinedChar; +}; + + +inline bool KCharColumn::showUnprintable() const { return ShowUnprintable; } +inline QChar KCharColumn::substituteChar() const { return SubstituteChar; } +inline QChar KCharColumn::undefinedChar() const { return UndefinedChar; } + +inline bool KCharColumn::setSubstituteChar( QChar SC ) +{ + if( SubstituteChar == SC ) + return false; + SubstituteChar = SC; + return true; +} + +inline bool KCharColumn::setUndefinedChar( QChar UC ) +{ + if( UndefinedChar == UC ) + return false; + UndefinedChar = UC; + return true; +} + +inline bool KCharColumn::setShowUnprintable( bool SU ) +{ + if( ShowUnprintable == SU ) + return false; + ShowUnprintable = SU; + return true; +} + +} + +#endif diff --git a/khexedit/lib/kcoltextexport.h b/khexedit/lib/kcoltextexport.h new file mode 100644 index 0000000..d0b3918 --- /dev/null +++ b/khexedit/lib/kcoltextexport.h @@ -0,0 +1,40 @@ +/*************************************************************************** + kcoltextexport.h - description + ------------------- + begin : Sam Aug 30 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KCOLTEXTEXPORT_H +#define KHE_KCOLTEXTEXPORT_H + +class QString; + +namespace KHE +{ +/** + * interface for the text export of columns + * @author Friedrich W. H. Kossebau <Friedrich.W.H@Kossebau.de> + */ +class KColTextExport +{ + public: // API + virtual void printFirstLine( QString &T, int Line ) const = 0; + virtual void printNextLine( QString &T ) const = 0; + /** tells how much chars per line are needed */ + virtual int charsPerLine() const = 0; +}; + +} + +#endif diff --git a/khexedit/lib/kcolumn.cpp b/khexedit/lib/kcolumn.cpp new file mode 100644 index 0000000..f9b0ce5 --- /dev/null +++ b/khexedit/lib/kcolumn.cpp @@ -0,0 +1,60 @@ +/*************************************************************************** + kcolumn.cpp - description + ------------------- + begin : Mit Mai 21 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// qt specific +#include <qpainter.h> +// lib specific +#include "kcolumnsview.h" +#include "kcolumn.h" + +using namespace KHE; + + +KColumn::KColumn( KColumnsView *V ) + : View( V ), + Visible( true ), //TODO: would false be better? + LineHeight( V->lineHeight() ), + XSpan( 0,0,true ) +{ + V->addColumn( this ); +} + + +void KColumn::paintFirstLine( QPainter *P, KPixelXs, int /*FirstLine*/ ) +{ + paintBlankLine( P ); +} + + +void KColumn::paintNextLine( QPainter *P ) +{ + paintBlankLine( P ); +} + + +void KColumn::paintBlankLine( QPainter *P ) const +{ + if( LineHeight > 0 ) + P->fillRect( 0,0,width(),LineHeight, View->backgroundBrush() ); +} + + +void KColumn::paintEmptyColumn( QPainter *P, KPixelXs Xs, KPixelYs Ys ) +{ + Xs.restrictTo( XSpan ); + P->fillRect( Xs.start(), Ys.start(), Xs.width(), Ys.width(), View->backgroundBrush() ); +} diff --git a/khexedit/lib/kcolumn.h b/khexedit/lib/kcolumn.h new file mode 100644 index 0000000..37c3118 --- /dev/null +++ b/khexedit/lib/kcolumn.h @@ -0,0 +1,126 @@ +/*************************************************************************** + kcolumn.h - description + ------------------- + begin : Mit Mai 21 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KCOLUMN_H +#define KHE_KCOLUMN_H + + +// lib specific +#include "kadds.h" +#include "ksection.h" + +class QPainter; + +namespace KHE +{ + +class KColumnsView; + +/** base class for columns of the KColumnsView + * + * + *@author Friedrich W. H. Kossebau + */ + +class KColumn +{ +// friend class KColumnsView; + public: + KColumn( KColumnsView *V ); + virtual ~KColumn() {} + + + public: // API to be reimplemented in the subclasses + /** Before an update of the columns view each column that intersects with the area to be painted + * will be called with this function. As often multiple lines of a column are affected + * for each lines the same values (like first and last char positions) might be calculated. + * This function enables a one-time-calculation for such data that must be stored in some + * class members, though. + * @param P painter variable + * @param cx + * @param cw + * @param FirstLine no of the first of the range of lines to paint + */ + virtual void paintFirstLine( QPainter *P, KPixelXs Xs, int FirstLine ); + /** the actual painting call for a column's line. + * The default implementation simply paints the background + */ + virtual void paintNextLine( QPainter *P ); + + /** */ + virtual void paintEmptyColumn( QPainter *P, KPixelXs Xs, KPixelYs Ys ); + + public: // modification access + /** sets starting point of the column */ + void setX( KPixelX NewX ); + /** sets visibily */ + void setVisible( bool V ); + /** buffer actual line height in column */ + void setLineHeight( KPixelY H ); + + public: // value access + /** left offset x in pixel */ + KPixelX x() const; + /** total width in pixel */ + KPixelX width() const; + /** right offset x in pixel */ + KPixelX rightX() const; + /** should Column be displayed? */ + bool isVisible() const; + /** convinience: returns width if visible else 0 */ + KPixelX visibleWidth() const; + + public: // functional logic + /** true if column overlaps with pixels between x-positions x1, x2 */ + bool overlaps( KPixelXs Xs ) const; + + protected: + /** sets width of the column */ + void setWidth( KPixelX W ); + /** */ + void paintBlankLine( QPainter *P ) const; + + protected: // general column data + /** pointer to the view */ + KColumnsView *View; + /** should Column be displayed? */ + bool Visible; + + /** buffered value */ + KPixelY LineHeight; + + /** left offset x in pixel */ + KPixelXs XSpan; +}; + + +inline KPixelX KColumn::x() const { return XSpan.start(); } +inline KPixelX KColumn::rightX() const { return XSpan.end(); } +inline KPixelX KColumn::width() const { return XSpan.width(); } +inline bool KColumn::isVisible() const { return Visible; } +inline KPixelX KColumn::visibleWidth() const { return Visible ? XSpan.width(): 0; } + +inline void KColumn::setX( KPixelX NewX ) { XSpan.moveToStart( NewX ); } +inline void KColumn::setWidth( KPixelX W ) { XSpan.setEndByWidth( W ); } +inline void KColumn::setVisible( bool V ) { Visible = V; } +inline void KColumn::setLineHeight( KPixelY H ) { LineHeight = H; } + +inline bool KColumn::overlaps( KPixelXs Xs ) const { return XSpan.overlaps(Xs); } + +} + +#endif diff --git a/khexedit/lib/kcolumnsview.cpp b/khexedit/lib/kcolumnsview.cpp new file mode 100644 index 0000000..1c93af8 --- /dev/null +++ b/khexedit/lib/kcolumnsview.cpp @@ -0,0 +1,236 @@ +/*************************************************************************** + kcolumnsview.cpp - description + ------------------- + begin : Mit Mai 21 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +//#include <kdebug.h> + +// qt specific +#include <qpainter.h> +// lib specific +#include "kcolumn.h" +#include "kcolumnsview.h" + + +using namespace KHE; + +static bool DefaultHorizontalGrid = false; + +KColumnsView::KColumnsView( /*bool R,*/ QWidget *Parent, const char *Name, WFlags Flags ) + : QScrollView( Parent, Name, Flags | WRepaintNoErase /*| WStaticContents*/ ), + NoOfLines( 0 ), + LineHeight( 0 ), + TotalWidth( 0 ), + HorizontalGrid( DefaultHorizontalGrid ), +// Reversed( R ), + d( 0 ) +{ + viewport()->setBackgroundMode( PaletteBase ); + setBackgroundMode( PaletteBackground, PaletteBase ); + viewport()->setFocusProxy( this ); + + Columns.setAutoDelete( true ); +} + +KColumnsView::~KColumnsView() +{ +} + + +void KColumnsView::setNoOfLines( int NewNoOfLines ) +{ + NoOfLines = NewNoOfLines; +} + + +void KColumnsView::setLineHeight( KPixelY LH ) +{ + LineHeight = LH; + for( KColumn *C=Columns.first(); C; C=Columns.next() ) + C->setLineHeight( LineHeight ); + verticalScrollBar()->setLineStep( LineHeight ); + + updateLineBufferSize(); +} + + +void KColumnsView::updateWidths() +{ + TotalWidth = 0; + for( KColumn *C=Columns.first(); C; C=Columns.next() ) + { + C->setX( TotalWidth ); + TotalWidth += C->visibleWidth(); + } + + updateLineBufferSize(); +} + + +void KColumnsView::updateLineBufferSize() +{ + int w = totalWidth(); + int h = LineHeight; + + if( w != LineBuffer.width() || h != LineBuffer.height() ) + LineBuffer.resize( w, h ); +} + + +int KColumnsView::noOfLinesPerPage() const +{ + if( !viewport() || LineHeight == 0 ) + return 1; +// int NoOfLinesPerPage = (visibleHeight()-1) / LineHeight; // -1 ensures to get always the last visible line + int NoOfLinesPerPage = (viewport()->height()-1) / LineHeight; // -1 ensures to get always the last visible line + + if( NoOfLinesPerPage == 0 ) + // ensure to move down at least one line + NoOfLinesPerPage = 1; + return NoOfLinesPerPage; +} + + +void KColumnsView::addColumn( KColumn *C ) +{ +// if( Reversed ) +// Columns.prepend( C ); +// else + Columns.append( C ); + + updateWidths(); +} + + +void KColumnsView::removeColumn( KColumn *C ) +{ + Columns.remove( C ); + + updateWidths(); +} + + +void KColumnsView::updateView() +{ + resizeContents( totalWidth(), totalHeight() ); + updateContents(); +} + + +void KColumnsView::repaintView() +{ + resizeContents( totalWidth(), totalHeight() ); + repaintContents( false ); +} + + +void KColumnsView::paintEmptyArea( QPainter *P, int cx ,int cy, int cw, int ch) +{ + P->fillRect( cx, cy, cw, ch, backgroundBrush() ); +} + + +void KColumnsView::drawContents( QPainter *P, int cx, int cy, int cw, int ch ) +{ + //kdDebug(1501) << "drawContents(" << cx<<","<<cw<<"#"<<cy<<","<<ch<<")\n"; + KPixelXs AffectedXs( cx, cw, true ); + // content to be shown? + if( AffectedXs.startsBefore(TotalWidth) ) + { + KPixelYs AffectedYs( cy, ch, true ); + + // collect affected columns + QPtrList<KColumn> RedrawColumns; + for( KColumn *C=Columns.first(); C; C=Columns.next() ) + if( C->isVisible() && C->overlaps(AffectedXs) ) + RedrawColumns.append( C ); + + // any lines to be drawn? + if( NoOfLines > 0 ) + { + // calculate affected lines + KSection AffectedLines = visibleLines( AffectedYs ); + AffectedLines.restrictEndTo( NoOfLines - 1 ); + + if( AffectedLines.isValid() ) + { + QPainter Paint; + Paint.begin( &LineBuffer, this ); + + // starting painting with the first line + KColumn *C = RedrawColumns.first(); + Paint.translate( C->x(), 0 ); + + for( ; C; C=RedrawColumns.next() ) + { + C->paintFirstLine( &Paint, AffectedXs, AffectedLines.start() ); + Paint.translate( C->width(), 0 ); + } + + // Go through the other lines + KPixelY y = AffectedLines.start() * LineHeight; + int l = AffectedLines.start(); + while( true ) + { + Paint.end(); + P->drawPixmap( cx, y, LineBuffer, cx, 0, cw, LineHeight ); // bitBlt directly impossible: lack of real coord + + // copy to screen +// bitBlt( viewport(), cx - contentsX(), y - contentsY(), +// &LineBuffer, cx, 0, cw, LineHeight ); + + ++l; + y += LineHeight; + + if( l > AffectedLines.end() ) + break; + + // to avoid flickers we first paint to the linebuffer + Paint.begin( &LineBuffer, this ); + + KColumn *C = RedrawColumns.first(); + Paint.translate( C->x(), 0 ); + + for( ; C; C=RedrawColumns.next() ) + { + C->paintNextLine( &Paint ); + Paint.translate( C->width(), 0 ); + } + + if( HorizontalGrid && cx < TotalWidth ) + Paint.drawLine( cx, LineHeight-1, TotalWidth-1, LineHeight-1 ); // TODO: use a additional TotalHeight? + } + } + } + + // draw empty columns? + AffectedYs.setStart( totalHeight() ); + if( AffectedYs.isValid() ) + { + for( KColumn *C = RedrawColumns.first(); C; C=RedrawColumns.next() ) + C->paintEmptyColumn( P, AffectedXs, AffectedYs ); + } + } + + // Paint empty rects + AffectedXs.setStart( TotalWidth ); + if( AffectedXs.isValid() ) + paintEmptyArea( P, AffectedXs.start(), cy, AffectedXs.width(), ch ); +} + +// Implemented to get rid of a compiler warning +void KColumnsView::drawContents( QPainter * ) {} + +#include "kcolumnsview.moc" diff --git a/khexedit/lib/kcolumnsview.h b/khexedit/lib/kcolumnsview.h new file mode 100644 index 0000000..aa3521d --- /dev/null +++ b/khexedit/lib/kcolumnsview.h @@ -0,0 +1,168 @@ +/*************************************************************************** + kcolumnsview.h - description + ------------------- + begin : Mit Mai 21 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KCOLUMNSVIEW_H +#define KHE_KCOLUMNSVIEW_H + +// qt specific +#include <qptrlist.h> +#include <qwidget.h> +#include <qpixmap.h> +#include <qscrollview.h> +// lib specific +#include "kadds.h" +#include "ksection.h" // TODO: think about moving this out of the public API + +namespace KHE +{ + +class KColumn; +class KColumnsViewPrivate; + +/** general class for widgets with columns that display different aspects of the same data + * with the same lineheight for all lines + * + *@author Friedrich W. H. Kossebau + */ + +class KColumnsView : public QScrollView +{ + Q_OBJECT + + friend class KColumn; + + public: + KColumnsView( /*bool R = false,*/ QWidget *parent=0, const char *name=0, WFlags Flags=0 ); + virtual ~KColumnsView(); + + public: // drawing + virtual void paintEmptyArea( QPainter *p, int cx, int cy, int cw, int ch ); + virtual void drawContents( QPainter *p, int cx, int cy, int cw, int ch ); + + public: // data-wise sizes + /** returns the number of all lines */ + int noOfLines() const; + /** returns number of fully visible lines, at least 1 (as needed by page down/up) + * doesn't care about the total height being smaller than the display height + */ + int noOfLinesPerPage() const; + + public: // pixel-wise sizes + /** returns the height of each line */ + KPixelY lineHeight() const; + /** returns the size of all visible columns together */ + QSize totalViewSize() const; + /** returns the width of all visible columns together */ + KPixelX totalWidth() const; + /** returns the height of all lines together */ + KPixelY totalHeight() const; + + public: // services + /** gives the index of the line that would include y in pixel coord. + * y is not forced to be inside the total height. + */ + uint lineAt( KPixelY y ) const; + /** gives the index of the first and the last line that would be visible + * these lines might not contain anything + */ + KSection visibleLines() const; + /** gives the index of the first and the last line that would be visible in the given pixel range + * these lines might not contain anything + */ + KSection visibleLines( KPixelYs YPixels ) const; + + + protected: + /** called by KColumn */ + void addColumn( KColumn *C ); + void removeColumn( KColumn *C ); + + + protected: // + /** sets height of all lines and propagates this information to all columns + * doesn't update the content size + * @param NewLineHeight height in pixels + */ + virtual void setLineHeight( KPixelY NewLineHeight ); + /** sets the number of lines + * doesn't update the content size + * @param NewNoOfLines new number of lines to display + */ + virtual void setNoOfLines( int NewNoOfLines ); + + protected: // recalculations + /** recalculates the positions of the columns and the total width */ + void updateWidths(); + /** ensures that the line buffer has the size of the whole line */ + void updateLineBufferSize(); + + protected: // painting + void updateView(); + void repaintView(); + + private: + /** hiding it*/ + void drawContents( QPainter* ); + + + protected: // calculated + /** collection of all the columns. All columns will be autodeleted. */ + QPtrList<KColumn> Columns; + /** the number of lines which the column view has */ + int NoOfLines; + /** the height of each line in pixels */ + KPixelY LineHeight; + /** the width of all visible columns together */ + KPixelX TotalWidth; +// /** width that is used by columns that are not resizeable (if shown) */ +// KPixelX ReservedWidth; + + protected: + // TODO: do we really want this? + bool HorizontalGrid; + /** Buffer where each line is drawn to before it is copied onto the screen */ + QPixmap LineBuffer; +// bool Reversed; + + private: + KColumnsViewPrivate *d; +}; + + +inline int KColumnsView::noOfLines() const { return NoOfLines; } +inline KPixelY KColumnsView::lineHeight() const { return LineHeight; } +inline uint KColumnsView::lineAt( KPixelY y ) const { return LineHeight!=0 ? y / LineHeight : 0; } +inline KSection KColumnsView::visibleLines() const +{ + KPixelY cy = contentsY(); + KPixelY ch = visibleHeight(); + return KSection( lineAt(cy), lineAt(cy+ch-1) ); +} + +inline KSection KColumnsView::visibleLines( KPixelYs YPixels ) const +{ + return KSection( lineAt(YPixels.start()), lineAt(YPixels.end()) ); +} + +inline KPixelY KColumnsView::totalHeight() const { return NoOfLines*LineHeight; } +inline KPixelX KColumnsView::totalWidth() const { return TotalWidth; } + +inline QSize KColumnsView::totalViewSize() const { return QSize( totalWidth(), totalHeight() ); } + +} + +#endif diff --git a/khexedit/lib/kcoordrange.h b/khexedit/lib/kcoordrange.h new file mode 100644 index 0000000..0d5b186 --- /dev/null +++ b/khexedit/lib/kcoordrange.h @@ -0,0 +1,95 @@ +/*************************************************************************** + kcoordrange.h - description + ------------------- + begin : Sun 03.08.2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de +****************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KCOORDRANGE_H +#define KHE_KCOORDRANGE_H + +// lib specific +#include "krange.h" +#include "kbuffercoord.h" +#include "ksection.h" + +namespace KHE +{ + +template<> +inline const KBufferCoord KRange<KBufferCoord>::null() const { return KBufferCoord(-1,-1);} + +typedef KRange<KBufferCoord> KBasicCoordRange; + +/** describes a range in the buffercoord + *@author Friedrich W. H. Kossebau + */ +class KCoordRange : public KRange<KBufferCoord> +{ + public: + /** + * @param SC start coord + * @param EC end coord + */ + KCoordRange( KBufferCoord SC, KBufferCoord EC ); + /** + * @param Pos start and end pos + * @param Lines start and end line + */ + KCoordRange( KSection Pos, KSection Lines ); + KCoordRange(); + ~KCoordRange(); + + public: + KCoordRange &operator=( const KCoordRange &S ); + + public: + bool operator==( const KCoordRange &S ) const; + + public: + /** calculates the number of coords that are covered if a line has the given length. + * If the range is invalid the behaviour is undefined. + * @param LineLength + * @return the number of points covered if a line has a length of LineLength. + */ + int width( int LineLength ) const; + /** calculates the number of lines that are covered by the range. + * If the range is invalid the behaviour is undefined. + * @return number of lines covered + */ + int lines() const; + /** tests if the given line is included by the range. + * If the range is invalid or the line < 0 the behaviour is undefined. + * @param Line index of line + * @return @c true if Line is included, otherwise @c false + */ + bool includesLine( int Line ) const; +}; + + +inline KCoordRange::KCoordRange( KBufferCoord SC, KBufferCoord EC ) : KBasicCoordRange(SC,EC) {} +inline KCoordRange::KCoordRange( KSection Pos, KSection Lines ) + : KBasicCoordRange( KBufferCoord(Pos.start(),Lines.start()), KBufferCoord(Pos.end(),Lines.end()) ) {} +inline KCoordRange::KCoordRange() {} +inline KCoordRange::~KCoordRange() {} + +inline bool KCoordRange::operator==( const KCoordRange &R ) const { return KBasicCoordRange::operator==(R); } + +inline KCoordRange &KCoordRange::operator=( const KCoordRange &R ) { KBasicCoordRange::operator=(R); return *this; } + +inline int KCoordRange::width( int LineLength ) const { return LineLength*(lines()-1) + End.pos() - Start.pos()+1; } +inline int KCoordRange::lines() const { return End.line() - Start.line() + 1; } +inline bool KCoordRange::includesLine( int Line ) const { return Line >= Start.line() && Line <= End.line(); } +} + +#endif diff --git a/khexedit/lib/kcoordrangelist.cpp b/khexedit/lib/kcoordrangelist.cpp new file mode 100644 index 0000000..3028c7d --- /dev/null +++ b/khexedit/lib/kcoordrangelist.cpp @@ -0,0 +1,78 @@ +/*************************************************************************** + kcoordrangelist.cpp - description + ------------------- + begin : Mon Jun 30 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "kcoordrangelist.h" + +using namespace KHE; + +KCoordRangeList::KCoordRangeList() +{ +} + + +KCoordRangeList::~KCoordRangeList() +{ +} + + +void KCoordRangeList::addCoordRange( KCoordRange NewCoordRange ) +{ + if( !NewCoordRange.isValid() ) + return; + // we try to insert it by ascending indizes + // if sections are overlapping we combine them + iterator S = begin(); + for( ; S!=end(); ++S ) + { + // is next CoordRange behind the new CoordRange? + if( NewCoordRange.endsBefore(*S) ) + { + // put the new before it + insert( S, NewCoordRange ); + return; + } + + // does the next CoordRange overlap? + if( (*S).overlaps(NewCoordRange) ) + { + // Start of the combined sections is the smaller one + NewCoordRange.extendStartTo( (*S).start() ); + // next we search all the overlapping sections and keep the highest end index + KBufferCoord End((*S).end()); + iterator LS = S; + for( ++LS; LS!=end(); ++LS ) + { + if( !(*LS).overlaps(NewCoordRange) ) + break; + End = (*LS).end(); + } + // the higher end is the end of the combined CoordRange + NewCoordRange.extendEndTo( End ); + // remove all overlapping sections + S = erase( S, LS ); + // and instead insert the combined one + insert( S, NewCoordRange ); + return; + } + } + + // all others are before the new? + if( S == end() ) + // add it at the end + append( NewCoordRange ); +} diff --git a/khexedit/lib/kcoordrangelist.h b/khexedit/lib/kcoordrangelist.h new file mode 100644 index 0000000..187ec7f --- /dev/null +++ b/khexedit/lib/kcoordrangelist.h @@ -0,0 +1,44 @@ +/*************************************************************************** + kcoordrangelist.h - description + ------------------- + begin : Wed Aug 13 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KCOORDRANGELIST_H +#define KHE_KCOORDRANGELIST_H + +// qt specific +#include <qvaluelist.h> +// lib specific +#include "kcoordrange.h" + +namespace KHE { + +typedef QValueList<KCoordRange> KCoordRangeBasicList; +/** +@author Friedrich W. H. Kossebau +*/ +class KCoordRangeList : public KCoordRangeBasicList +{ + public: + KCoordRangeList(); + ~KCoordRangeList(); + + public: + void addCoordRange( KCoordRange S ); +}; + +} + +#endif diff --git a/khexedit/lib/kcursor.cpp b/khexedit/lib/kcursor.cpp new file mode 100644 index 0000000..3150751 --- /dev/null +++ b/khexedit/lib/kcursor.cpp @@ -0,0 +1,49 @@ +/*************************************************************************** + kcursor.cpp - description + ------------------- + begin : Mit Jun 26 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#include "kcursor.h" + +using namespace KHE; + +KCursor::KCursor() +: CursorX( 0 ), + CursorW( -1 ) +{ +} + + +KCursor::~KCursor() +{ +} + + + +void KCursor::setSize( KPixelX Width, KPixelY Height ) +{ + if( Width != OnPixmap.width() || Height != OnPixmap.height() ) + { + OnPixmap.resize( Width, Height ); + OffPixmap.resize( Width, Height ); + } +} + + +void KCursor::setShape( KPixelX X, KPixelX W ) +{ + CursorX = X; + CursorW = W; +} diff --git a/khexedit/lib/kcursor.h b/khexedit/lib/kcursor.h new file mode 100644 index 0000000..428c7ed --- /dev/null +++ b/khexedit/lib/kcursor.h @@ -0,0 +1,68 @@ +/*************************************************************************** + kbuffercolumn.h - description + ------------------- + begin : Mit Jun 26 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KCURSOR_H +#define KHE_KCURSOR_H + + +#include <qpixmap.h> + +#include "kadds.h" + +namespace KHE +{ + +/** + *@author Friedrich W. H. Kossebau + */ +class KCursor +{ + public: + KCursor(); + virtual ~KCursor(); + + public: + /** sets size of the full cursor */ + void setSize( KPixelX Width, KPixelY Height ); + /** sets the shape of the cursor to be drawn */ + void setShape( KPixelX X, KPixelX W ); + + public: // access + const QPixmap &onPixmap() const; + const QPixmap &offPixmap() const; + KPixelX cursorX() const; + KPixelX cursorW() const; + + + protected: + QPixmap OnPixmap; + QPixmap OffPixmap; + + KPixelX CursorX; + KPixelX CursorW; +}; + + +inline const QPixmap &KCursor::onPixmap() const { return OnPixmap; } +inline const QPixmap &KCursor::offPixmap() const { return OffPixmap; } + +inline KPixelX KCursor::cursorX() const { return CursorX; } +inline KPixelX KCursor::cursorW() const { return CursorW; } + +} + +#endif diff --git a/khexedit/lib/kdatabuffer.cpp b/khexedit/lib/kdatabuffer.cpp new file mode 100644 index 0000000..054d792 --- /dev/null +++ b/khexedit/lib/kdatabuffer.cpp @@ -0,0 +1,51 @@ +/*************************************************************************** + kdatabuffer.cpp - description + ------------------- + begin : Fri Aug 01 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// c specific +#include <ctype.h> +// lib specific +#include "kdatabuffer.h" + +using namespace KHE; + + +int KDataBuffer::insert( int Pos, const char* D, int Length ) +{ + return replace( Pos,0,D,Length ); +} + + +int KDataBuffer::remove( KSection Remove ) +{ + replace( Remove, 0, 0 ); + return Remove.width(); // TODO: check if this is true +} + +int KDataBuffer::copyTo( char* Dest, int Pos, int Length ) const +{ + return copyTo( Dest, KSection(Pos,Length,false) ); +} + + + +int KDataBuffer::copyTo( char* Dest, KSection Source ) const +{ + Source.restrictEndTo( size()-1 ); + for( int i=Source.start(); i<=Source.end(); ++i ) + *Dest++ = datum( i ); + return Source.width(); +} diff --git a/khexedit/lib/kdatabuffer.h b/khexedit/lib/kdatabuffer.h new file mode 100644 index 0000000..e9733d8 --- /dev/null +++ b/khexedit/lib/kdatabuffer.h @@ -0,0 +1,246 @@ +/*************************************************************************** + kdatabuffer.h - description + ------------------- + begin : Mit Mai 14 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KDATABUFFER_H +#define KHE_KDATABUFFER_H + + +// lib specific +#include "ksection.h" +#include "khexedit_export.h" + +namespace KHE +{ + +/** could it be useful to hide the data access behind an iterator? * +class KDataBufferIterator +{ + public: + bool hasNext(); + char next(); + protected: + + protected: + char * + int Length; +} + +bool KDataBufferIterator::hasNext() +{ +} +// this function should be simple as possible +char KDataBufferIterator::next() +{ + // if next span is empty + if( ) + return *NextChar++; +} +*/ +/** base class for all Data buffers that are used to display + * TODO: think about a way to inform KHexEdit that there has been + * a change in the buffer outside. what kind of changes are possible? + * + * Operations on the data: + * + * Finding: is implemented stateless. FindNext has to be done by perhaps a FindManager + * Replacing: not available. Implement within a ReplaceManager + * + *@author Friedrich W. H. Kossebau + */ + +class KHEXEDIT_EXPORT KDataBuffer +{ + friend class KDataBufferIterator; + + + protected: + KDataBuffer(); + public: + virtual ~KDataBuffer(); + + + public: // data access API + /** locates working range + * The idea behind is to tell buffer which range will be requested in the following time, + * so that e.g. the corresponding pages will be loaded in advance + * TODO: do we really need this? Where will this lead to real enhancements? + * @param Range + * @return @c true if successfull, @c false otherwise + */ + virtual bool prepareRange( KSection Range ) const = 0; + /** convenience function, same as above */ + bool prepareRange( int Offset, int Length ) const; + + /** creates an iterator to */ + //virtual KDataBufferIterator *iterator() const = 0; + /** expects pointer to memory, should be in prepared range + * it is only expected to be a valid pointer until any further call + * to this or any modifying function + * @param Section + * @return pointer to + */ + virtual const char *dataSet( KSection Section ) const = 0; + /** convenience function, same as above */ + const char *dataSet( int Offset, int Length ) const; + + /** requests a single byte + * if the offset is not valid the behaviout is undefined + * @param Offset offset of the datum requested + */ + virtual char datum( unsigned int Offset ) const = 0; + + /** + * @return the size of the data + */ + virtual int size() const = 0; + + + public: // state read API + /** + * @return @c true if the buffer can only be read, @c false if writing is allowed + */ + virtual bool isReadOnly() const; + /** + * @return @c true if the buffer has been modified, @c false otherwise + */ + virtual bool isModified() const = 0; + + + public: // modification API + /** inserts bytes copied from the given source at Position. + * The original data beginnung at the position is moved + * with the buffer enlarged as needed + * If the buffer is readOnly this is a noop and returns 0. + * @param Pos + * @param Source data source + * @param SourceLength number of bytes to copy + * @return length of inserted data + */ + virtual int insert( int Pos, const char* Source, int SourceLength ); + + /** removes beginning with position as much as possible + * @param Section + * @return length of removed data + */ + virtual int remove( KSection Section ); + /** convenience function, behaves as above */ + int remove( int Pos, int Length ); + + /** replaces as much as possible + * @param DestSection + * @param Source + * @param SourceLength + * @return length of replacced data + */ + virtual unsigned int replace( KSection DestSection, const char* Source, unsigned int SourceLength ) = 0; + /** convenience function, behaves as above */ + unsigned int replace( unsigned int Pos, unsigned int RemoveLength, + const char* Source, unsigned int SourceLength ); + + /** moves a part of the data to a new position, while floating the other data around + * when moving to a higher place the length of the block must be taken into account + * if the new positions extend beyond the buffers end the section is moved to the end. + * @param DesPos position of the data where the section should be moved behind + * @param SourceSection data section to be moved + * @return new pos of moved data or old, if failed + */ + virtual int move( int DestPos, KSection SourceSection ) = 0; + + /** + * fills the buffer with the FillChar. If the buffer is to small it will be extended as much as possible. + * @param FillChar char to use + * @param Length number of chars to fill. If Length is -1, the current buffer length is used. + * @param Pos position where the filling starts + * @return number of filled characters + */ + virtual int fill( const char FillChar, int Length = -1, unsigned int Pos = 0 ) = 0; + + /** sets a single byte + * if the offset is not valid the behaviour is undefined + * @param Offset offset of the datum requested + * @param Char new byte value + */ + virtual void setDatum( unsigned int Offset, const char Char ) = 0; + + /** sets the modified flag for the buffer + * @param M + */ + virtual void setModified( bool M ) = 0; + + + public: // service functions + /** copies the data of the section into a given array Dest. If the section extends the buffers range + * the section is limited to the buffer's end. If the section is invalid the behaviour is undefined. + * @param Dest pointer to a char array large enough to hold the copied section + * @param Source + * @return number of copied bytes + */ + virtual int copyTo( char* Dest, KSection Source ) const; + /** convenience function, behaves as above */ + int copyTo( char* Dest, int Pos, int n ) const; + + + public: // finding API + /** searches beginning with byte at Pos. + * @param + * @param Length length of search string + * @param Pos the position to start the search + * @return index of the first or -1 + */ + //virtual int find( const char*, int Length, int Pos = 0 ) const = 0; + /** searches for a given data string + * The section limits the data within which the key has to be found + * If the end of the section is lower then the start the search continues at the start??? + * @param + * @param Length length of search string + * @param Section section within the keydata is to be found + * @return index of the first occurence or -1 + */ + virtual int find( const char*KeyData, int Length, KSection Section ) const = 0; + /** searches backward beginning with byte at Pos. + * @param + * @param Length length of search string + * @param Pos the position to start the search. If -1 the search starts at the end. + * @return index of the first or -1 + */ + virtual int rfind( const char*, int Length, int Pos = -1 ) const = 0; + +/* virtual int find( const QString &expr, bool cs, bool wo, bool forward = true, int *index = 0 ); */ +}; + + +inline KDataBuffer::KDataBuffer() {} +inline KDataBuffer::~KDataBuffer() {} + +inline bool KDataBuffer::prepareRange( int Offset, int Length ) const +{ return prepareRange( KSection(Offset,Offset+Length-1) ); } + +inline const char *KDataBuffer::dataSet( int Offset, int Length ) const +{ return dataSet( KSection(Offset,Offset+Length-1) ); } + +inline int KDataBuffer::remove( int Pos, int Length ) +{ return remove( KSection(Pos,Pos+Length-1) ); } + +inline unsigned int KDataBuffer::replace( unsigned int Pos, unsigned int RemoveLength, + const char* D, unsigned int InputLength ) +{ return replace( KSection(Pos,Pos+RemoveLength-1), D, InputLength ); } + +inline bool KDataBuffer::isReadOnly() const { return false; } + +} + +#endif diff --git a/khexedit/lib/kfixedsizebuffer.cpp b/khexedit/lib/kfixedsizebuffer.cpp new file mode 100644 index 0000000..2945620 --- /dev/null +++ b/khexedit/lib/kfixedsizebuffer.cpp @@ -0,0 +1,272 @@ +/*************************************************************************** + kfixedsizebuffer.cpp - description + ------------------- + begin : Mit Jun 03 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + +//#include <kdebug.h> +// c specific +#include <string.h> +// lib specific +#include "kfixedsizebuffer.h" + +using namespace KHE; + +KFixedSizeBuffer::KFixedSizeBuffer( char *D, unsigned int S, char FUC ) + : Data( D ), + Size( S ), + FillUpChar( FUC ), + ReadOnly( true ), + Modified( false ), + AutoDelete( false ) +{ +} + +KFixedSizeBuffer::KFixedSizeBuffer( unsigned int S, char FUC ) + : Data( new char[S] ), + Size( S ), + FillUpChar( FUC ), + ReadOnly( false ), + Modified( false ), + AutoDelete( true ) +{ + reset( 0, S ); +} + +KFixedSizeBuffer::~KFixedSizeBuffer() +{ + if( AutoDelete ) + delete [] Data; +} + + + +int KFixedSizeBuffer::insert( int Pos, const char* D, int InputLength ) +{ + // check all parameters + if( Pos >= (int)Size || InputLength == 0 ) + return 0; + if( Pos + InputLength > (int)Size ) + InputLength = Size - Pos; + + unsigned int BehindInsertPos = Pos + InputLength; + // fmove right data behind the input range + memmove( &Data[BehindInsertPos], &Data[Pos], Size-BehindInsertPos ); + // insert input + memcpy( &Data[Pos], D, InputLength ); + + Modified = true; + return InputLength; +} + + +int KFixedSizeBuffer::remove( KSection Remove ) +{ + if( Remove.start() >= (int)Size || Remove.width() == 0 ) + return 0; + + Remove.restrictEndTo( Size-1 ); + + int RemoveLength = Remove.width(); + int BehindRemovePos = Remove.end()+1;; + // fmove right data behind the input range + memmove( &Data[Remove.start()], &Data[BehindRemovePos], Size-BehindRemovePos ); + // clear freed space + reset( Size-RemoveLength, RemoveLength ); + + Modified = true; + return RemoveLength; +} + + +unsigned int KFixedSizeBuffer::replace( KSection Remove, const char* D, unsigned int InputLength ) +{ + // check all parameters + if( Remove.startsBehind( Size-1 ) || (Remove.width()==0 && InputLength==0) ) + return 0; + + Remove.restrictEndTo( Size-1 ); + if( Remove.start() + InputLength > Size ) + InputLength = Size - Remove.start(); + + int SizeDiff = InputLength - Remove.width(); + + // is input longer than removed? + if( SizeDiff > 0 ) + { + unsigned int BehindInsertPos = Remove.start() + InputLength; + // fmove right data behind the input range + memmove( &Data[BehindInsertPos], &Data[Remove.end()+1], Size-BehindInsertPos ); + } + // is input smaller than removed? + else if( SizeDiff < 0 ) + { + unsigned int BehindRemovePos = Remove.end()+1; + // fmove right data behind the input range + memmove( &Data[Remove.start()+InputLength], &Data[BehindRemovePos], Size-BehindRemovePos ); + // clear freed space + reset( Size+SizeDiff, -SizeDiff ); + } + // insert input + memcpy( &Data[Remove.start()], D, InputLength ); + + Modified = true; + return InputLength; +} + + +int KFixedSizeBuffer::move( int DestPos, KSection SourceSection ) +{ + // check all parameters + if( SourceSection.start() >= (int)Size || SourceSection.width() == 0 + || DestPos > (int)Size || SourceSection.start() == DestPos ) + return SourceSection.start(); + + SourceSection.restrictEndTo( Size-1 ); + bool ToRight = DestPos > SourceSection.start(); + int MovedLength = SourceSection.width(); + int DisplacedLength = ToRight ? DestPos - SourceSection.end()-1 : SourceSection.start() - DestPos; + + // find out section that is smaller + int SmallPartLength, LargePartLength, SmallPartStart, LargePartStart, SmallPartDest, LargePartDest; + // moving part is smaller? + if( MovedLength < DisplacedLength ) + { + SmallPartStart = SourceSection.start(); + SmallPartLength = MovedLength; + LargePartLength = DisplacedLength; + // moving part moves right? + if( ToRight ) + { + SmallPartDest = DestPos - MovedLength; + LargePartStart = SourceSection.end()+1; + LargePartDest = SourceSection.start(); + } + else + { + SmallPartDest = DestPos; + LargePartStart = DestPos; + LargePartDest = DestPos + MovedLength; + } + } + else + { + LargePartStart = SourceSection.start(); + LargePartLength = MovedLength; + SmallPartLength = DisplacedLength; + // moving part moves right? + if( ToRight ) + { + LargePartDest = DestPos - MovedLength; + SmallPartStart = SourceSection.end()+1; + SmallPartDest = SourceSection.start(); + } + else + { + LargePartDest = DestPos; + SmallPartStart = DestPos; + SmallPartDest = DestPos + MovedLength; + } + } + + // copy smaller part to tempbuffer + char *Temp = new char[SmallPartLength]; + memcpy( Temp, &Data[SmallPartStart], SmallPartLength ); + + // move the larger part + memmove( &Data[LargePartDest], &Data[LargePartStart], LargePartLength ); + + // copy smaller part to its new dest + memcpy( &Data[SmallPartDest], Temp, SmallPartLength ); + delete [] Temp; + + Modified = true; + return MovedLength < DisplacedLength ? SmallPartDest : LargePartDest; +} + + +int KFixedSizeBuffer::fill( const char FChar, int FillLength, unsigned int Pos ) +{ + // nothing to fill + if( Pos >= Size ) + return 0; + + unsigned int LengthToEnd = Size - Pos; + + if( FillLength < 0 || FillLength > (int)LengthToEnd ) + FillLength = LengthToEnd; + + memset( &Data[Pos], FChar, FillLength ); + Modified = true; + return FillLength; +} + + +int KFixedSizeBuffer::compare( const KDataBuffer &Other, KSection OtherRange, unsigned int Pos ) +{ + //kdDebug() << QString("Pos: %1, OtherRange: (%3/%4)" ).arg(Pos).arg(OtherRange.start()).arg(OtherRange.end()) + // << endl; + // test other values + if( OtherRange.startsBehind(Other.size()-1) ) + return 1; + + // check own values + if( Pos >= Size ) + return -1; + + int ValueByLength = 0; // default: equal + + KSection Range( Pos, OtherRange.width(), true ); + int Last = Other.size()-1; + // + if( OtherRange.endsBehind(Last) ) + { + // make shorter + OtherRange.setEnd( Last ); + if( OtherRange.width() < Range.width() ) + ValueByLength = 1; + } + Last = Size-1; + if( Range.endsBehind(Last) ) + { + // make shorter + Range.setEnd( Last ); + if( OtherRange.width() > Range.width() ) + ValueByLength = -1; + } + //kdDebug() + // << QString( "Range: (%1/%2), OtherRange: (%3/%4)" ).arg(Range.start()).arg(Range.end()).arg(OtherRange.start()).arg(OtherRange.end()) + // << endl; + int oi = OtherRange.start(); + for( int i=Range.start(); i<=Range.end(); ++i,++oi ) + { + char OD = Other.datum(oi); + char D = Data[i]; + //kdDebug() << QString("%1==%2").arg((int)D).arg((int)OD) << endl; + if( OD == D ) + continue; + return OD < D ? 1 : -1; + } + + return ValueByLength; +} + + +int KFixedSizeBuffer::find( const char*/*KeyData*/, int /*Length*/, KSection /*Section*/ ) const { return 0; } +int KFixedSizeBuffer::rfind( const char*, int /*Length*/, int /*Pos*/ ) const { return 0; } + + +void KFixedSizeBuffer::reset( unsigned int Pos, unsigned int Length ) +{ + memset( &Data[Pos], FillUpChar, Length ); +} diff --git a/khexedit/lib/kfixedsizebuffer.h b/khexedit/lib/kfixedsizebuffer.h new file mode 100644 index 0000000..15c17da --- /dev/null +++ b/khexedit/lib/kfixedsizebuffer.h @@ -0,0 +1,116 @@ +/*************************************************************************** + kfixedsizebuffer.h - description + ------------------- + begin : Mit Jun 03 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KFIXEDSIZEBUFFER_H +#define KHE_KFIXEDSIZEBUFFER_H + +#include "kdatabuffer.h" + +namespace KHE +{ + +/** base class for all Data buffers that are used to display + * TODO: think about a way to inform KHexEdit that there has been + * a change in the buffer outside. what kind of changes are possible? + *@author Friedrich W. H. Kossebau + */ + +class KFixedSizeBuffer : public KDataBuffer +{ + public: + /** creates a readonly buffer around the given data */ + KFixedSizeBuffer( char *D, unsigned int S, char FUC = '\0' ); + /** creates a writeable buffer which is deleted at the end */ + KFixedSizeBuffer( unsigned int S, char FUC = '\0' ); + virtual ~KFixedSizeBuffer(); + + public: // KDataBuffer API + virtual bool prepareRange( KSection Range ) const; + virtual const char *dataSet( KSection S ) const; + virtual char datum( unsigned int Offset ) const; + virtual int size() const; + virtual bool isReadOnly() const; + virtual bool isModified() const; + + virtual int insert( int Pos, const char*, int Length ); + virtual int remove( KSection Remove ); + virtual unsigned int replace( KSection Remove, const char*, unsigned int InputLength ); + virtual int move( int DestPos, KSection SourceSection ); + virtual int fill( const char FillChar, int Length = -1, unsigned int Pos = 0 ); + virtual void setDatum( unsigned int Offset, const char Char ); + + virtual void setModified( bool M = true ); + + virtual int find( const char*KeyData, int Length, KSection Section ) const; + virtual int rfind( const char*, int Length, int Pos = -1 ) const; + +/* virtual int find( const QString &expr, bool cs, bool wo, bool forward = true, int *index = 0 ); */ + + public: + void setReadOnly( bool RO = true ); + int compare( const KDataBuffer &Other, KSection Range, unsigned int Pos = 0 ); + int compare( const KDataBuffer &Other, int OtherPos, int Length, unsigned int Pos = 0 ); + int compare( const KDataBuffer &Other ); + + public: + char *rawData() const; + + protected: + void reset( unsigned int Pos, unsigned int Length ); + + protected: + /** */ + char *Data; + /***/ + unsigned int Size; + /** */ + char FillUpChar; + /** */ + bool ReadOnly:1; + /** */ + bool Modified:1; + /** */ + bool AutoDelete:1; +}; + + +inline bool KFixedSizeBuffer::prepareRange( KSection ) const { return true; } +inline const char *KFixedSizeBuffer::dataSet( KSection S ) const { return &Data[S.start()]; } + +inline char KFixedSizeBuffer::datum( unsigned int Offset ) const { return Data[Offset]; } +inline int KFixedSizeBuffer::size() const { return Size; } + +inline void KFixedSizeBuffer::setDatum( unsigned int Offset, const char Char ) +{ Data[Offset] = Char; Modified = true; } + +inline bool KFixedSizeBuffer::isReadOnly() const { return ReadOnly; } +inline bool KFixedSizeBuffer::isModified() const { return Modified; } + +inline void KFixedSizeBuffer::setReadOnly( bool RO ) { ReadOnly = RO; } +inline void KFixedSizeBuffer::setModified( bool M ) { Modified = M; } + +inline int KFixedSizeBuffer::compare( const KDataBuffer &Other ) +{ return compare( Other, KSection(0,Other.size()-1),0 ); } + +inline int KFixedSizeBuffer::compare( const KDataBuffer &Other, int OtherPos, int Length, unsigned int Pos ) +{ return compare( Other, KSection(OtherPos,Length,true),Pos ); } + +inline char *KFixedSizeBuffer::rawData() const { return Data; } + +} + +#endif diff --git a/khexedit/lib/khe.h b/khexedit/lib/khe.h new file mode 100644 index 0000000..af029ea --- /dev/null +++ b/khexedit/lib/khe.h @@ -0,0 +1,95 @@ +/*************************************************************************** + khe.h - description + ------------------- + begin : Mon Jul 14 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KHE_H +#define KHE_KHE_H + +// here we collect all general data +// let's see how much it gets ;) + +namespace KHE +{ + enum KCoding { HexadecimalCoding=0, DecimalCoding=1, OctalCoding=2, BinaryCoding=3, MaxCodingId=0xFFFF }; + static const int NoOfCodings = 4; + + /** */ + enum KEncoding + { + /** the coding of your shell */ + LocalEncoding=0, + /** ASCII encoding, also known as Latin1 */ + ISO8859_1Encoding, + /** */ + ISO8859_2Encoding, + /** */ + ISO8859_3Encoding, + /** */ + ISO8859_4Encoding, + /** */ + ISO8859_5Encoding, + /** */ + ISO8859_6Encoding, + /** */ + ISO8859_7Encoding, + /** */ + ISO8859_8Encoding, + /** */ + ISO8859_8_IEncoding, + /** */ + ISO8859_9Encoding, + /** */ + ISO8859_11Encoding, + /** */ + ISO8859_13Encoding, + /** */ + ISO8859_15Encoding, + /** */ + CP1250Encoding, + /** */ + CP1251Encoding, + /** */ + CP1252Encoding, + /** */ + CP1253Encoding, + /** */ + CP1254Encoding, + /** */ + CP1255Encoding, + /** */ + CP1256Encoding, + /** */ + CP1257Encoding, + /** */ + CP1258Encoding, + /** */ + IBM850Encoding, + /** */ + IBM866Encoding, + /** */ + KOI8_REncoding, + /** */ + KOI8_UEncoding, + /** the most common EBCDIC codepage */ + EBCDIC1047Encoding, + /** Offset for own encodings which are bound in by plugins */ + StartOfOwnEncoding=0x8000, + /** this should enable extension without breaking binary compatibility */ + MaxEncodingId=0xFFFF + }; +} + +#endif diff --git a/khexedit/lib/khechar.h b/khexedit/lib/khechar.h new file mode 100644 index 0000000..4f51e9e --- /dev/null +++ b/khexedit/lib/khechar.h @@ -0,0 +1,44 @@ +/*************************************************************************** + helper.h - description + ------------------- + begin : Do Nov 25 2004 + copyright : (C) 2004 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + +#ifndef KHE_KHECHAR_H +#define KHE_KHECHAR_H + +// qt specific +#include <qstring.h> + +namespace KHE +{ + +class KHEChar : public QChar +{ + public: + KHEChar( QChar C ); + KHEChar( QChar C, bool U ); + public: + bool isUndefined() const; + protected: + // the byte is not defined + bool IsUndefined:1; +}; + +inline KHEChar::KHEChar( QChar C ) : QChar( C ), IsUndefined( false ) {} +inline KHEChar::KHEChar( QChar C, bool U ) : QChar( C ), IsUndefined( U ) {} +inline bool KHEChar::isUndefined() const { return IsUndefined; } + +} + +#endif diff --git a/khexedit/lib/khexedit.cpp b/khexedit/lib/khexedit.cpp new file mode 100644 index 0000000..85478e5 --- /dev/null +++ b/khexedit/lib/khexedit.cpp @@ -0,0 +1,2032 @@ +/*************************************************************************** + khexedit.cpp - description + ------------------- + begin : Die Mai 13 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +//#include <kdebug.h> + +// c specific +#include <stdlib.h> +//#include <limits.h> +// c++ specific +//#include <limits> +// qt specific +#include <qstyle.h> +#include <qpainter.h> +#include <qtimer.h> +#include <qcursor.h> +#include <qapplication.h> +// kde specific +#ifndef QT_ONLY +#include <kglobalsettings.h> +#endif +// lib specific +#include "kdatabuffer.h" +#include "koffsetcolumn.h" +#include "kvaluecolumn.h" +#include "kcharcolumn.h" +#include "kbordercolumn.h" +#include "kbuffercursor.h" +#include "kbufferlayout.h" +#include "kbufferranges.h" +#include "controller/ktabcontroller.h" +#include "controller/knavigator.h" +#include "controller/kvalueeditor.h" +#include "controller/kchareditor.h" +#include "kbufferdrag.h" +#include "kcursor.h" +#include "kbytecodec.h" +#include "kcharcodec.h" +#include "kwordbufferservice.h" +#include "khexedit.h" + +using namespace KHE; + +// zooming is done in steps of font size points +static const int DefaultZoomStep = 1; +static const int DefaultStartOffset = 0;//5; +static const int DefaultFirstLineOffset = 0; +static const int DefaultNoOfBytesPerLine = 16; +static const KHexEdit::KResizeStyle DefaultResizeStyle = KHexEdit::FullSizeUsage; +static const KHexEdit::KEncoding DefaultEncoding = KHexEdit::LocalEncoding; +static const int DefaultScrollTimerPeriod = 100; +static const int InsertCursorWidth = 2; + + + +KHexEdit::KHexEdit( KDataBuffer *Buffer, QWidget *Parent, const char *Name, WFlags Flags ) + : KColumnsView( Parent, Name, Flags ), + DataBuffer( Buffer ), + BufferLayout( new KBufferLayout(DefaultNoOfBytesPerLine,DefaultStartOffset,0) ), + BufferCursor( new KBufferCursor(BufferLayout) ), + BufferRanges( new KBufferRanges(BufferLayout) ), + CursorBlinkTimer( new QTimer(this) ), + ScrollTimer( new QTimer(this) ), + DragStartTimer( new QTimer(this) ), + TrippleClickTimer( new QTimer(this) ), + CursorPixmaps( new KCursor() ), + Codec( 0 ), + ClipboardMode( QClipboard::Clipboard ), + ResizeStyle( DefaultResizeStyle ), + Encoding( MaxEncodingId ), // forces update + ReadOnly( false ), +// Modified( false ), + OverWriteOnly( false ), + OverWrite( true ), + MousePressed( false ), + InDoubleClick( false ), + InDnD( false ), + DragStartPossible( false ), + CursorPaused( false ), + BlinkCursorVisible( false ), + InZooming( false ), + d( 0 ) +{ + // initalize layout + if( DataBuffer ) + BufferLayout->setLength( DataBuffer->size() ); + BufferLayout->setNoOfLinesPerPage( noOfLinesPerPage() ); + + // creating the columns in the needed order + OffsetColumn = new KOffsetColumn( this, DefaultFirstLineOffset, DefaultNoOfBytesPerLine, KOffsetFormat::Hexadecimal ); + FirstBorderColumn = new KBorderColumn( this, false ); + ValueColumn = new KValueColumn( this, DataBuffer, BufferLayout, BufferRanges ); + SecondBorderColumn = new KBorderColumn( this, true ); + CharColumn = new KCharColumn( this, DataBuffer, BufferLayout, BufferRanges ); + + // select the active column + ActiveColumn = &charColumn(); + InactiveColumn = &valueColumn(); + + // set encoding + Codec = KCharCodec::createCodec( (KHE::KEncoding)DefaultEncoding ); + valueColumn().setCodec( Codec ); + charColumn().setCodec( Codec ); + Encoding = DefaultEncoding; + + TabController = new KTabController( this, 0 ); + Navigator = new KNavigator( this, TabController ); + ValueEditor = new KValueEditor( ValueColumn, BufferCursor, this, Navigator ); + CharEditor = new KCharEditor( CharColumn, BufferCursor, this, Navigator ); + + Controller = Navigator; + +#ifdef QT_ONLY + QFont FixedFont( "fixed", 10 ); + FixedFont.setFixedPitch( true ); + setFont( FixedFont ); +#else + setFont( KGlobalSettings::fixedFont() ); +#endif + + // get the full control + viewport()->setFocusProxy( this ); + viewport()->setFocusPolicy( WheelFocus ); + + viewport()->installEventFilter( this ); + installEventFilter( this ); + + connect( CursorBlinkTimer, SIGNAL(timeout()), this, SLOT(blinkCursor()) ); + connect( ScrollTimer, SIGNAL(timeout()), this, SLOT(autoScrollTimerDone()) ); + connect( DragStartTimer, SIGNAL(timeout()), this, SLOT(startDrag()) ); + + viewport()->setAcceptDrops( true ); +} + + +KHexEdit::~KHexEdit() +{ + delete TabController; + delete Navigator; + delete ValueEditor; + delete CharEditor; +} + + +int KHexEdit::noOfBytesPerLine() const { return BufferLayout->noOfBytesPerLine(); } +int KHexEdit::firstLineOffset() const { return OffsetColumn->firstLineOffset(); } +int KHexEdit::startOffset() const { return BufferLayout->startOffset(); } +KHexEdit::KResizeStyle KHexEdit::resizeStyle() const { return ResizeStyle; } +KHexEdit::KCoding KHexEdit::coding() const { return (KHexEdit::KCoding)valueColumn().coding(); } +KPixelX KHexEdit::byteSpacingWidth() const { return valueColumn().byteSpacingWidth(); } +int KHexEdit::noOfGroupedBytes() const { return valueColumn().noOfGroupedBytes(); } +KPixelX KHexEdit::groupSpacingWidth() const { return valueColumn().groupSpacingWidth(); } +KPixelX KHexEdit::binaryGapWidth() const { return valueColumn().binaryGapWidth(); } +bool KHexEdit::isOverwriteMode() const { return OverWrite; } +bool KHexEdit::isOverwriteOnly() const { return OverWriteOnly; } +bool KHexEdit::isReadOnly() const { return ReadOnly; } +bool KHexEdit::isModified() const { return DataBuffer->isModified(); } +bool KHexEdit::tabChangesFocus() const { return TabController->tabChangesFocus(); } +bool KHexEdit::showUnprintable() const { return charColumn().showUnprintable(); } +QChar KHexEdit::substituteChar() const { return charColumn().substituteChar(); } +QChar KHexEdit::undefinedChar() const { return charColumn().undefinedChar(); } +KHexEdit::KEncoding KHexEdit::encoding() const { return (KHexEdit::KEncoding)Encoding; } +const QString &KHexEdit::encodingName() const { return Codec->name(); } + +KSection KHexEdit::selection() const { return BufferRanges->selection(); } +int KHexEdit::cursorPosition() const { return BufferCursor->index(); } +bool KHexEdit::isCursorBehind() const { return BufferCursor->isBehind(); } +KHexEdit::KBufferColumnId KHexEdit::cursorColumn() const +{ return static_cast<KHE::KValueColumn *>( ActiveColumn ) == &valueColumn()? ValueColumnId : CharColumnId; } + +void KHexEdit::setOverwriteOnly( bool OO ) { OverWriteOnly = OO; if( OverWriteOnly ) setOverwriteMode( true ); } +void KHexEdit::setModified( bool M ) { DataBuffer->setModified(M); } +void KHexEdit::setTabChangesFocus( bool TCF ) { TabController->setTabChangesFocus(TCF); } +void KHexEdit::setFirstLineOffset( int FLO ) { OffsetColumn->setFirstLineOffset( FLO ); } + +bool KHexEdit::offsetColumnVisible() const { return OffsetColumn->isVisible(); } +int KHexEdit::visibleBufferColumns() const +{ return (valueColumn().isVisible() ? ValueColumnId : 0) | (charColumn().isVisible() ? CharColumnId : 0); } + + +void KHexEdit::setOverwriteMode( bool OM ) +{ + if( (OverWriteOnly && !OM) || (OverWrite == OM) ) + return; + + OverWrite = OM; + + // affected: + // cursor shape + bool ChangeCursor = !( CursorPaused || ValueEditor->isInEditMode() ); + if( ChangeCursor ) + pauseCursor(); + + BufferCursor->setAppendPosEnabled( !OverWrite ); + + if( ChangeCursor ) + unpauseCursor(); + + emit cutAvailable( !OverWrite && BufferRanges->hasSelection() ); +} + + +void KHexEdit::setDataBuffer( KDataBuffer *B ) +{ + //pauseCursor(); + ValueEditor->reset(); + CursorPaused = true; + + DataBuffer = B; + valueColumn().set( DataBuffer ); + charColumn().set( DataBuffer); + + // affected: + // length -> no of lines -> width + BufferLayout->setLength( DataBuffer->size() ); + adjustLayoutToSize(); + + // ensure that the widget is readonly if the buffer is + if( DataBuffer->isReadOnly() ) + setReadOnly( true ); + + updateView(); + BufferCursor->gotoStart(); + ensureCursorVisible(); + unpauseCursor(); +} + + +void KHexEdit::setStartOffset( int SO ) +{ + if( !BufferLayout->setStartOffset(SO) ) + return; + + pauseCursor(); + // affects: + // the no of lines -> width + adjustLayoutToSize(); + + updateView(); + + BufferCursor->updateCoord(); + ensureCursorVisible(); + unpauseCursor(); +} + + +void KHexEdit::setReadOnly( bool RO ) +{ + // don't set editor readwrite if databuffer is readonly + ReadOnly = (DataBuffer && DataBuffer->isReadOnly()) ? true : RO; + + Controller = ReadOnly ? (KController*)Navigator : + cursorColumn() == CharColumnId ? (KController*)CharEditor : (KController*)ValueEditor; +} + + +void KHexEdit::setBufferSpacing( KPixelX ByteSpacing, int NoOfGroupedBytes, KPixelX GroupSpacing ) +{ + if( !valueColumn().setSpacing(ByteSpacing,NoOfGroupedBytes,GroupSpacing) ) + return; + + updateViewByWidth(); +} + + +void KHexEdit::setCoding( KCoding C ) +{ + uint OldCodingWidth = valueColumn().byteCodec()->encodingWidth(); + + if( !valueColumn().setCoding((KHE::KCoding)C) ) + return; + + uint NewCodingWidth = valueColumn().byteCodec()->encodingWidth(); + ValueEditor->ByteBuffer.setLength( NewCodingWidth ); //hack for now + + // no change in the width? + if( NewCodingWidth == OldCodingWidth ) + updateColumn( valueColumn() ); + else + updateViewByWidth(); +} + + +void KHexEdit::setResizeStyle( KResizeStyle NewStyle ) +{ + if( ResizeStyle == NewStyle ) + return; + + ResizeStyle = NewStyle; + + updateViewByWidth(); +} + + +void KHexEdit::setNoOfBytesPerLine( int NoBpL ) +{ + // if the number is explicitly set we expect a wish for no automatic resize + ResizeStyle = NoResize; + + if( !BufferLayout->setNoOfBytesPerLine(NoBpL) ) + return; + updateViewByWidth(); +} + + +void KHexEdit::setByteSpacingWidth( int/*KPixelX*/ BSW ) +{ + if( !valueColumn().setByteSpacingWidth(BSW) ) + return; + updateViewByWidth(); +} + +void KHexEdit::setNoOfGroupedBytes( int NoGB ) +{ + if( !valueColumn().setNoOfGroupedBytes(NoGB) ) + return; + updateViewByWidth(); +} + + +void KHexEdit::setGroupSpacingWidth( int/*KPixelX*/ GSW ) +{ + if( !valueColumn().setGroupSpacingWidth(GSW) ) + return; + updateViewByWidth(); +} + + +void KHexEdit::setBinaryGapWidth( int/*KPixelX*/ BGW ) +{ + if( !valueColumn().setBinaryGapWidth(BGW) ) + return; + updateViewByWidth(); +} + + +void KHexEdit::setSubstituteChar( QChar SC ) +{ + if( !charColumn().setSubstituteChar(SC) ) + return; + pauseCursor(); + updateColumn( charColumn() ); + unpauseCursor(); +} + +void KHexEdit::setUndefinedChar( QChar UC ) +{ + if( !charColumn().setUndefinedChar(UC) ) + return; + pauseCursor(); + updateColumn( charColumn() ); + unpauseCursor(); +} + +void KHexEdit::setShowUnprintable( bool SU ) +{ + if( !charColumn().setShowUnprintable(SU) ) + return; + pauseCursor(); + updateColumn( charColumn() ); + unpauseCursor(); +} + + +void KHexEdit::setEncoding( KEncoding C ) +{ + if( Encoding == C ) + return; + + KCharCodec *NC = KCharCodec::createCodec( (KHE::KEncoding)C ); + if( NC == 0 ) + return; + + valueColumn().setCodec( NC ); + charColumn().setCodec( NC ); + + delete Codec; + Codec = NC; + Encoding = C; + + pauseCursor(); + updateColumn( valueColumn() ); + updateColumn( charColumn() ); + unpauseCursor(); +} + +// TODO: join with function above! +void KHexEdit::setEncoding( const QString& EncodingName ) +{ + if( EncodingName == Codec->name() ) + return; + + KCharCodec *NC = KCharCodec::createCodec( EncodingName ); + if( NC == 0 ) + return; + + valueColumn().setCodec( NC ); + charColumn().setCodec( NC ); + + delete Codec; + Codec = NC; + Encoding = LocalEncoding; // TODO: add encoding no to every known codec + + pauseCursor(); + updateColumn( valueColumn() ); + updateColumn( charColumn() ); + unpauseCursor(); +} + + +void KHexEdit::fontChange( const QFont &OldFont ) +{ + QScrollView::fontChange( OldFont ); + + if( !InZooming ) + DefaultFontSize = font().pointSize(); + + // get new values + QFontMetrics FM( fontMetrics() ); + KPixelX DigitWidth = FM.maxWidth(); + KPixelY DigitBaseLine = FM.ascent(); + + setLineHeight( FM.height() ); + + // update all dependant structures + BufferLayout->setNoOfLinesPerPage( noOfLinesPerPage() ); + + OffsetColumn->setMetrics( DigitWidth, DigitBaseLine ); + valueColumn().setMetrics( DigitWidth, DigitBaseLine ); + charColumn().setMetrics( DigitWidth, DigitBaseLine ); + + updateViewByWidth(); +} + + +void KHexEdit::updateViewByWidth() +{ + pauseCursor(); + + adjustToLayoutNoOfBytesPerLine(); + adjustLayoutToSize(); + + updateView(); + + BufferCursor->updateCoord(); + ensureCursorVisible(); + + unpauseCursor(); +} + + +void KHexEdit::zoomIn() { zoomIn( DefaultZoomStep ); } +void KHexEdit::zoomOut() { zoomOut( DefaultZoomStep ); } + +void KHexEdit::zoomIn( int PointInc ) +{ + InZooming = true; + QFont F( font() ); + F.setPointSize( QFontInfo(F).pointSize() + PointInc ); + setFont( F ); + InZooming = false; +} + +void KHexEdit::zoomOut( int PointDec ) +{ + InZooming = true; + QFont F( font() ); + F.setPointSize( QMAX( 1, QFontInfo(F).pointSize() - PointDec ) ); + setFont( F ); + InZooming = false; +} + + +void KHexEdit::zoomTo( int PointSize ) +{ + InZooming = true; + QFont F( font() ); + F.setPointSize( PointSize ); + setFont( F ); + InZooming = false; +} + + +void KHexEdit::unZoom() +{ + zoomTo( DefaultFontSize ); +} + + +void KHexEdit::adjustLayoutToSize() +{ + // check whether there is a change with the numbers of fitting bytes per line + if( ResizeStyle != NoResize ) + { + int FittingBytesPerLine = fittingBytesPerLine( size() ); + +// std::cout<<"FitBpL"<<FittingBytesPerLine<<std::endl; + + // changes? + if( BufferLayout->setNoOfBytesPerLine(FittingBytesPerLine) ) + adjustToLayoutNoOfBytesPerLine(); + } + + setNoOfLines( BufferLayout->noOfLines() ); +} + + +void KHexEdit::adjustToLayoutNoOfBytesPerLine() +{ + OffsetColumn->setDelta( BufferLayout->noOfBytesPerLine() ); + valueColumn().resetXBuffer(); + charColumn().resetXBuffer(); + + updateWidths(); +} + + +void KHexEdit::setNoOfLines( int NewNoOfLines ) +{ + KColumnsView::setNoOfLines( NewNoOfLines>1?NewNoOfLines:1 ); +} + + +void KHexEdit::toggleOffsetColumn( bool Visible ) +{ + bool OCVisible = OffsetColumn->isVisible(); + // no change? + if( OCVisible == Visible ) + return; + + OffsetColumn->setVisible( Visible ); + FirstBorderColumn->setVisible( Visible ); + + updateViewByWidth(); +} + + +QSize KHexEdit::sizeHint() const +{ + return QSize( totalWidth(), totalHeight() ); +} + + +QSize KHexEdit::minimumSizeHint() const +{ + // TODO: better minimal width (visibility!) + return QSize( OffsetColumn->visibleWidth()+FirstBorderColumn->visibleWidth()+SecondBorderColumn->visibleWidth()+valueColumn().byteWidth()+charColumn().byteWidth(), + lineHeight() + noOfLines()>1? style().pixelMetric(QStyle::PM_ScrollBarExtent):0 ); +} + + +void KHexEdit::resizeEvent( QResizeEvent *ResizeEvent ) +{ + if( ResizeStyle != NoResize ) + { + int FittingBytesPerLine = fittingBytesPerLine( ResizeEvent->size() ); + + // changes? + if( BufferLayout->setNoOfBytesPerLine(FittingBytesPerLine) ) + { + setNoOfLines( BufferLayout->noOfLines() ); + updateViewByWidth(); + } + } + + QScrollView::resizeEvent( ResizeEvent ); + + BufferLayout->setNoOfLinesPerPage( noOfLinesPerPage() ); // TODO: doesn't work with the new size!!! +} + + +int KHexEdit::fittingBytesPerLine( const QSize &NewSize ) const +{ + KPixelX ReservedWidth = OffsetColumn->visibleWidth() + FirstBorderColumn->visibleWidth() + SecondBorderColumn->visibleWidth(); + + // abstract framewidth as well as offset and border columns width + int UsedbyFrameWidth = 2 * frameWidth(); + KPixelX FullWidth = NewSize.width() - UsedbyFrameWidth - ReservedWidth; + +// // no width left for resizeable columns? TODO: put this in resizeEvent +// if( FullWidth < 0 ) +// return; + + KPixelY FullHeight = NewSize.height() - UsedbyFrameWidth; + + // check influence of dis-/appearing of the vertical scrollbar + bool VerticalScrollbarIsVisible = verticalScrollBar()->isVisible(); + KPixelX ScrollbarExtent = style().pixelMetric( QStyle::PM_ScrollBarExtent );//verticalScrollBar()->width(); + + KPixelX AvailableWidth = FullWidth; + if( VerticalScrollbarIsVisible ) + AvailableWidth -= ScrollbarExtent; + + enum KMatchTrial { FirstRun, RerunWithScrollbarOn, TestWithoutScrollbar }; + KMatchTrial MatchRun = FirstRun; + + // prepare needed values + KPixelX DigitWidth = valueColumn().digitWidth(); + KPixelX TextByteWidth = charColumn().isVisible() ? DigitWidth : 0; + KPixelX HexByteWidth = valueColumn().isVisible() ? valueColumn().byteWidth() : 0; + KPixelX ByteSpacingWidth = valueColumn().isVisible() ? valueColumn().byteSpacingWidth() : 0; + KPixelX GroupSpacingWidth; + int NoOfGroupedBytes = valueColumn().noOfGroupedBytes(); + // no grouping? + if( NoOfGroupedBytes == 0 ) + { + // faking grouping by 1 + NoOfGroupedBytes = 1; + GroupSpacingWidth = 0; + } + else + GroupSpacingWidth = valueColumn().isVisible() ? valueColumn().groupSpacingWidth() : 0; + + KPixelX HexByteGroupWidth = NoOfGroupedBytes * HexByteWidth + (NoOfGroupedBytes-1)*ByteSpacingWidth; + KPixelX TextByteGroupWidth = NoOfGroupedBytes * TextByteWidth; + KPixelX TotalGroupWidth = HexByteGroupWidth + GroupSpacingWidth + TextByteGroupWidth; + + int FittingBytesPerLine; + int WithScrollbarFittingBytesPerLine = 0; + for(;;) + { +// std::cout << "matchWidth: " << FullWidth +// << " (v:" << visibleWidth() +// << ", f:" << frameWidth() +// << ", A:" << AvailableWidth +// << ", S:" << ScrollbarExtent +// << ", R:" << ReservedWidth << ")" << std::endl; + + // calculate fitting groups per line + int FittingGroupsPerLine = (AvailableWidth+GroupSpacingWidth) // fake spacing after last group + / TotalGroupWidth; + + // calculate the fitting bytes per line by groups + FittingBytesPerLine = NoOfGroupedBytes * FittingGroupsPerLine; + + // not only full groups? + if( ResizeStyle == FullSizeUsage && NoOfGroupedBytes > 1 ) + { + if( FittingGroupsPerLine > 0 ) + AvailableWidth -= FittingGroupsPerLine*TotalGroupWidth; // includes additional spacing after last group + +// std::cout << "Left: " << AvailableWidth << "("<<HexByteWidth<<", "<<TextByteWidth<<")" << std::endl; + + if( AvailableWidth > 0 ) + FittingBytesPerLine += (AvailableWidth+ByteSpacingWidth) / (HexByteWidth+ByteSpacingWidth+TextByteWidth); + + // is there not even the space for a single byte? + if( FittingBytesPerLine == 0 ) + { + // ensure at least one byte per line + FittingBytesPerLine = 1; + // and + break; + } + } + // is there not the space for a single group? + else if( FittingBytesPerLine == 0 ) + { + // ensures at least one group + FittingBytesPerLine = NoOfGroupedBytes; + break; + } + +// std::cout << "meantime: " << FittingGroupsPerLine << " (T:" << TotalGroupWidth +// << ", h:" << HexByteGroupWidth +// << ", t:" << TextByteGroupWidth +// << ", s:" << GroupSpacingWidth << ") " <<FittingBytesPerLine<< std::endl; + + int NewNoOfLines = (BufferLayout->length()+BufferLayout->startOffset()+FittingBytesPerLine-1) + / FittingBytesPerLine; + KPixelY NewHeight = NewNoOfLines * LineHeight; + + if( VerticalScrollbarIsVisible ) + { + if( MatchRun == TestWithoutScrollbar ) + { + // did the test without the scrollbar fail, don't the data fit into the view? + if( NewHeight>FullHeight ) + // reset to old calculated value + FittingBytesPerLine = WithScrollbarFittingBytesPerLine; + break; + } + + // a chance for to perhaps fit in height? + if( FittingBytesPerLine <= BufferLayout->noOfBytesPerLine() ) + { + // remember this trial's result and calc number of bytes with vertical scrollbar on + WithScrollbarFittingBytesPerLine = FittingBytesPerLine; + AvailableWidth = FullWidth; + MatchRun = TestWithoutScrollbar; +// std::cout << "tested without scrollbar..." << std::endl; + continue; + } + } + else + { + // doesn't it fit into the height anymore? + if( NewHeight>FullHeight && MatchRun==FirstRun ) + { + // need for a scrollbar has risen... ->less width, new calculation + AvailableWidth = FullWidth - ScrollbarExtent; + MatchRun = RerunWithScrollbarOn; +// std::cout << "rerun with scrollbar on..." << std::endl; + continue; + } + } + + break; + } + + return FittingBytesPerLine; +} + + +bool KHexEdit::selectWord( /*unsigned TODO:change all unneeded signed into unsigned!*/ int Index ) +{ + if( Index >= 0 && Index < BufferLayout->length() ) + { + KWordBufferService WBS( DataBuffer, Codec ); + KSection WordSection = WBS.wordSection( Index ); + if( WordSection.isValid() ) + { + pauseCursor(); + + BufferRanges->setFirstWordSelection( WordSection ); + BufferCursor->gotoIndex( WordSection.end()+1 ); + repaintChanged(); + + unpauseCursor(); + return true; + } + } + return false; +} + +void KHexEdit::select( KSection Section ) +{ + if( !Section.isValid() ) + return; + + Section.restrictTo( KSection(0,BufferLayout->length()-1) ); + + pauseCursor(); + + BufferRanges->setSelection( Section ); + BufferCursor->gotoIndex( Section.end()+1 ); + repaintChanged(); + + unpauseCursor(); + + if( !OverWrite ) emit cutAvailable( BufferRanges->hasSelection() ); + emit copyAvailable( BufferRanges->hasSelection() ); + emit selectionChanged( Section.start(), Section.end() ); +} + +void KHexEdit::selectAll( bool Select ) +{ + KSection Selection; + + pauseCursor( true ); + + if( !Select ) + BufferRanges->removeSelection(); + else + { + Selection.set( 0, BufferLayout->length()-1 ); + BufferRanges->setSelection( Selection ); + BufferCursor->gotoEnd(); + } + + repaintChanged(); + + unpauseCursor(); + + if( !OverWrite ) emit cutAvailable( BufferRanges->hasSelection() ); + emit copyAvailable( BufferRanges->hasSelection() ); + emit selectionChanged( Selection.start(), Selection.end() ); + viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor ); +} + + +bool KHexEdit::hasSelectedData() const +{ + return BufferRanges->hasSelection(); +} + + +QByteArray KHexEdit::selectedData() const +{ + if( !BufferRanges->hasSelection() ) + return QByteArray(); + + KSection Selection = BufferRanges->selection(); + QByteArray SD( Selection.width() ); + DataBuffer->copyTo( SD.data(), Selection.start(), Selection.width() ); + return SD; +} + + +KBufferDrag *KHexEdit::dragObject( QWidget *Parent ) const +{ + if( !BufferRanges->hasSelection() ) + return 0; + + const KOffsetColumn *OC; + const KValueColumn *HC; + const KCharColumn *TC; + KCoordRange Range; + + if( static_cast<KHE::KCharColumn *>( ActiveColumn ) == &charColumn() ) + { + OC = 0; + HC = 0; + TC = 0; + } + else + { + OC = OffsetColumn->isVisible() ? OffsetColumn : 0; + HC = valueColumn().isVisible() ? &valueColumn() : 0; + TC = charColumn().isVisible() ? &charColumn() : 0; + KSection S = BufferRanges->selection(); + Range.set( BufferLayout->coordOfIndex(S.start()),BufferLayout->coordOfIndex(S.end()) ); + } + + return new KBufferDrag( selectedData(), Range, OC, HC, TC, + charColumn().substituteChar(), charColumn().undefinedChar(), + Codec->name(), Parent ); +} + + +void KHexEdit::cut() +{ + if( isReadOnly() || OverWrite ) + return; + + KBufferDrag *Drag = dragObject(); + if( !Drag ) + return; + + QApplication::clipboard()->setData( Drag, ClipboardMode ); + + removeSelectedData(); +} + + +void KHexEdit::copy() +{ + KBufferDrag *Drag = dragObject(); + if( !Drag ) + return; + + QApplication::clipboard()->setData( Drag, ClipboardMode ); +} + + +void KHexEdit::paste() +{ + if( isReadOnly() ) + return; + + QMimeSource *Source = QApplication::clipboard()->data( ClipboardMode ); + pasteFromSource( Source ); +} + + +void KHexEdit::pasteFromSource( QMimeSource *Source ) +{ + if( !Source || !KBufferDrag::canDecode(Source) ) + return; + + QByteArray Data; + if( !KBufferDrag::decode(Source,Data) ) + return; + + if( !Data.isEmpty() ) + insert( Data ); +} + + +void KHexEdit::insert( const QByteArray &D ) +{ + pauseCursor( true ); + + KSection ChangedRange; + + if( OverWrite ) + { + if( BufferRanges->hasSelection() ) + { + // replacing the selection: + // we restrict the replacement to the minimum length of selection and input + ChangedRange = BufferRanges->selection(); + ChangedRange.restrictEndTo( ChangedRange.start()+D.size()-1 ); + int W = DataBuffer->replace( ChangedRange, D.data(), ChangedRange.width() ); + BufferCursor->gotoCIndex( ChangedRange.start()+W ); + BufferRanges->removeSelection(); + } + else + { + if( !BufferCursor->isBehind() ) + { + // replacing the normal data, at least until the end + ChangedRange.setByWidth( BufferCursor->realIndex(), D.size() ); + ChangedRange.restrictEndTo( BufferLayout->length()-1 ); + if( ChangedRange.isValid() ) + { + int W = DataBuffer->replace( ChangedRange, D.data(), ChangedRange.width() ); + BufferCursor->gotoNextByte( W ); + } + } + } + } + else + { + if( BufferRanges->hasSelection() ) + { + // replacing the selection + KSection Selection = BufferRanges->selection(); + int OldLastIndex = BufferLayout->length() - 1; + int W = DataBuffer->replace( Selection, D.data(), D.size() ); + updateLength(); + BufferCursor->gotoIndex( Selection.start() + W ); + if( W > 0 ) + { + if( Selection.width() == (int)D.size() ) + ChangedRange = Selection; + else + { + int NewLastIndex = DataBuffer->size() - 1; + ChangedRange.set( Selection.start(), NewLastIndex>OldLastIndex?NewLastIndex:OldLastIndex ); + } + } + BufferRanges->removeSelection(); + } + else + { + bool Appending = BufferCursor->atAppendPos(); + int OldIndex = BufferCursor->realIndex(); + int W = DataBuffer->insert( OldIndex, D.data(), D.size() ); + updateLength(); + // worked? + if( W > 0 ) + { + if( Appending ) + BufferCursor->gotoEnd(); + else + BufferCursor->gotoNextByte( W ); + ChangedRange.set( OldIndex, DataBuffer->size()-1 ); + } + } + } + + bool Changed = ChangedRange.isValid(); + if( Changed ) + { + BufferRanges->addChangedRange( ChangedRange ); + repaintChanged(); + } + ensureCursorVisible(); + + unpauseCursor(); + + if( Changed ) emit bufferChanged( ChangedRange.start(), ChangedRange.end() ); + KSection Selection = BufferRanges->selection(); + emit selectionChanged( Selection.start(), Selection.end() ); +} + + +void KHexEdit::removeSelectedData() +{ + // Can't we do this? + if( isReadOnly() || OverWrite || ValueEditor->isInEditMode() ) + return; + + pauseCursor(); + + KSection Selection = BufferRanges->selection(); + + BufferRanges->removeFurtherSelections(); + + KSection ChangedRange = removeData( Selection ); + BufferRanges->removeSelection(); + + repaintChanged(); + + BufferCursor->gotoCIndex( Selection.start() ); + + ensureCursorVisible(); +// clearUndoRedo(); + viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor ); + + unpauseCursor(); + + if( ChangedRange.isValid() ) emit bufferChanged( ChangedRange.start(), ChangedRange.end() ); + emit selectionChanged( -1, -1 ); +} + + +KSection KHexEdit::removeData( KSection Indizes ) +{ +// if( undoEnabled ) +// { +// checkUndoRedoInfo( UndoRedoInfo::RemoveSelected ); +// if( !undoRedoInfo.valid() ) +// { +// doc->selectionStart( selNum, undoRedoInfo.id, undoRedoInfo.index ); +// undoRedoInfo.d->text = QString::null; +// } +// readFormats( c1, c2, undoRedoInfo.d->text, TRUE ); +// } + + KSection ChangedRange( Indizes.start(), BufferLayout->length()-1 ); + // do it! + DataBuffer->remove( Indizes ); + updateLength(); + BufferRanges->addChangedRange( ChangedRange ); + + return ChangedRange; +} + + +void KHexEdit::updateLength() +{ + BufferLayout->setLength( DataBuffer->size() ); + setNoOfLines( BufferLayout->noOfLines() ); +} + + +void KHexEdit::clipboardChanged() +{ + // don't listen to selection changes + disconnect( QApplication::clipboard(), SIGNAL(selectionChanged()), this, 0 ); + selectAll( false ); +} + + +void KHexEdit::setCursorPosition( int Index, bool Behind ) +{ + pauseCursor( true ); + + BufferCursor->gotoCIndex( Index ); + if( Behind ) + BufferCursor->stepBehind(); + + BufferRanges->removeSelection(); + bool RangesModifed = BufferRanges->isModified(); + if( RangesModifed ) + { + repaintChanged(); + + viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor ); + + } + ensureCursorVisible(); + unpauseCursor(); + + if( RangesModifed ) + { + if( !OverWrite ) emit cutAvailable( BufferRanges->hasSelection() ); + emit copyAvailable( BufferRanges->hasSelection() ); + emit selectionChanged( -1, -1 ); + } +} + + +void KHexEdit::showBufferColumns( int CCs ) +{ + int Columns = visibleBufferColumns(); + + // no changes or no column selected? + if( CCs == Columns || !(CCs&( ValueColumnId | CharColumnId )) ) + return; + + valueColumn().setVisible( ValueColumnId & CCs ); + charColumn().setVisible( CharColumnId & CCs ); + SecondBorderColumn->setVisible( CCs == (ValueColumnId|CharColumnId) ); + + // active column not visible anymore? + if( !activeColumn().isVisible() ) + { + KBufferColumn *H = ActiveColumn; + ActiveColumn = InactiveColumn; + InactiveColumn = H; + Controller = ReadOnly ? (KController*)Navigator : + cursorColumn() == CharColumnId ? (KController*)CharEditor : (KController*)ValueEditor; + } + + updateViewByWidth(); +} + + +void KHexEdit::setCursorColumn( KBufferColumnId CC ) +{ + // no changes or not visible? + if( CC == cursorColumn() + || (CC == ValueColumnId && !valueColumn().isVisible()) + || (CC == CharColumnId && !charColumn().isVisible()) ) + return; + + pauseCursor( true ); + + if( CC == ValueColumnId ) + { + ActiveColumn = &valueColumn(); + InactiveColumn = &charColumn(); + } + else + { + ActiveColumn = &charColumn(); + InactiveColumn = &valueColumn(); + } + Controller = ReadOnly ? (KController*)Navigator : + cursorColumn() == CharColumnId ? (KController*)CharEditor : (KController*)ValueEditor; + + ensureCursorVisible(); + unpauseCursor(); +} + + +void KHexEdit::placeCursor( const QPoint &Point ) +{ + resetInputContext(); + + // switch active column if needed + if( charColumn().isVisible() && Point.x() >= charColumn().x() ) + { + ActiveColumn = &charColumn(); + InactiveColumn = &valueColumn(); + } + else + { + ActiveColumn = &valueColumn(); + InactiveColumn = &charColumn(); + } + Controller = ReadOnly ? (KController*)Navigator : + cursorColumn() == CharColumnId ? (KController*)CharEditor : (KController*)ValueEditor; + + // get coord of click and whether this click was closer to the end of the pos + KBufferCoord C( activeColumn().magPosOfX(Point.x()), lineAt(Point.y()) ); + + BufferCursor->gotoCCoord( C ); +} + + +int KHexEdit::indexByPoint( const QPoint &Point ) const +{ + const KBufferColumn *C; + if( charColumn().isVisible() && Point.x() >= charColumn().x() ) + C = &charColumn(); + else + C = &valueColumn(); + + KBufferCoord Coord( C->posOfX(Point.x()), lineAt(Point.y()) ); + + return BufferLayout->indexAtCCoord( Coord ); +} + + +void KHexEdit::showEvent( QShowEvent *e ) +{ + KColumnsView::showEvent( e ); + BufferLayout->setNoOfLinesPerPage( noOfLinesPerPage() ); +} + + +bool KHexEdit::eventFilter( QObject *O, QEvent *E ) +{ + if( O == this || O == viewport() ) + { + if( E->type() == QEvent::FocusIn ) + { + startCursor(); + } + else if( E->type() == QEvent::FocusOut ) + { + stopCursor(); + } + } + +// if( O == this && E->type() == QEvent::PaletteChange ) +// { +// QColor old( viewport()->colorGroup().color(QColorGroup::Text) ); +// +// if( old != colorGroup().color(QColorGroup::Text) ) +// { +// QColor c( colorGroup().color(QColorGroup::Text) ); +// doc->setMinimumWidth( -1 ); +// doc->setDefaultFormat( doc->formatCollection()->defaultFormat()->font(), c ); +// lastFormatted = doc->firstParagraph(); +// formatMore(); +// repaintChanged(); +// } +// } + + return QScrollView::eventFilter( O, E ); +} + + +void KHexEdit::blinkCursor() +{ + // skip the cursor drawing? + if( CursorPaused || ValueEditor->isInEditMode() ) + return; + + // switch the cursor state + paintActiveCursor( !BlinkCursorVisible ); +} + + +void KHexEdit::startCursor() +{ + CursorPaused = false; + + updateCursor(); + + CursorBlinkTimer->start( QApplication::cursorFlashTime()/2 ); +} + + +void KHexEdit::unpauseCursor() +{ + CursorPaused = false; + + if( CursorBlinkTimer->isActive() ) + updateCursor(); +} + + +void KHexEdit::updateCursor() +{ + createCursorPixmaps(); + + paintActiveCursor( true ); + paintInactiveCursor( true ); +} + + +void KHexEdit::stopCursor() +{ + CursorBlinkTimer->stop(); + + pauseCursor(); +} + + +void KHexEdit::pauseCursor( bool LeaveEdit ) +{ + paintActiveCursor( false ); + paintInactiveCursor( false ); + + if( LeaveEdit ) + ValueEditor->InEditMode = false; + CursorPaused = true; +} + + +void KHexEdit::createCursorPixmaps() +{ + // create CursorPixmaps + CursorPixmaps->setSize( activeColumn().byteWidth(), LineHeight ); + + int Index = BufferCursor->validIndex(); + + QPainter Paint; + Paint.begin( &CursorPixmaps->offPixmap(), this ); + activeColumn().paintByte( &Paint, Index ); + Paint.end(); + + Paint.begin( &CursorPixmaps->onPixmap(), this ); + activeColumn().paintCursor( &Paint, Index ); + Paint.end(); + + // calculat the shape + KPixelX CursorX; + KPixelX CursorW; + if( BufferCursor->isBehind() ) + { + CursorX = QMAX( 0, CursorPixmaps->onPixmap().width()-InsertCursorWidth ); + CursorW = InsertCursorWidth; + } + else + { + CursorX = 0; + CursorW = OverWrite ? -1 : InsertCursorWidth; + } + CursorPixmaps->setShape( CursorX, CursorW ); +} + + +void KHexEdit::pointPainterToCursor( QPainter &Painter, const KBufferColumn &Column ) const +{ + int x = Column.xOfPos( BufferCursor->pos() ) - contentsX(); + int y = LineHeight * BufferCursor->line() - contentsY(); + + Painter.begin( viewport() ); + Painter.translate( x, y ); +} + + +void KHexEdit::paintActiveCursor( bool CursorOn ) +{ + // any reason to skip the cursor drawing? + if( !isUpdatesEnabled() || !viewport()->isUpdatesEnabled() + || (CursorOn && !hasFocus() && !viewport()->hasFocus() && !InDnD ) ) + return; + + QPainter Painter; + pointPainterToCursor( Painter, activeColumn() ); + + // paint edited byte? + if( ValueEditor->isInEditMode() ) + { + int Index = BufferCursor->index(); + + if( CursorOn ) + valueColumn().paintEditedByte( &Painter, ValueEditor->EditValue, ValueEditor->ByteBuffer ); + else + valueColumn().paintByte( &Painter, Index ); + } + else + { + + Painter.drawPixmap( CursorPixmaps->cursorX(), 0, + CursorOn?CursorPixmaps->onPixmap():CursorPixmaps->offPixmap(), + CursorPixmaps->cursorX(),0,CursorPixmaps->cursorW(),-1 ); + // store state + BlinkCursorVisible = CursorOn; + } +} + + +void KHexEdit::paintInactiveCursor( bool CursorOn ) +{ + // any reason to skip the cursor drawing? + if( !isUpdatesEnabled() + || !viewport()->isUpdatesEnabled() + || !inactiveColumn().isVisible() + || (CursorOn && !hasFocus() && !viewport()->hasFocus() && !InDnD) ) + return; + + int Index = BufferCursor->validIndex(); + + QPainter Painter; + pointPainterToCursor( Painter, inactiveColumn() ); + if( CursorOn ) + { + KBufferColumn::KFrameStyle Style = + BufferCursor->isBehind() ? KBufferColumn::Right : + (OverWrite||ValueEditor->isInEditMode()) ? KBufferColumn::Frame : + KBufferColumn::Left; + inactiveColumn().paintFramedByte( &Painter, Index, Style ); + } + else + inactiveColumn().paintByte( &Painter, Index ); +} + + +void KHexEdit::drawContents( QPainter *P, int cx, int cy, int cw, int ch ) +{ + KColumnsView::drawContents( P, cx, cy, cw, ch ); + // TODO: update non blinking cursors. Should this perhaps be done in the buffercolumn? + // Then it needs to know about inactive, insideByte and the like... well... + // perhaps subclassing the buffer columns even more, to KCharColumn and KValueColumn? + + if( !CursorPaused && visibleLines(KPixelYs(cy,ch,false)).includes(BufferCursor->line()) ) + { + paintActiveCursor( true ); + paintInactiveCursor( true ); + } +} + +void KHexEdit::updateColumn( KColumn &Column ) +{ + //kdDebug(1501) << "updateColumn\n"; + if( Column.isVisible() ) + updateContents( Column.x(), 0, Column.width(), totalHeight() ); +} + + +void KHexEdit::keyPressEvent( QKeyEvent *KeyEvent ) +{ + if( !Controller->handleKeyPress( KeyEvent ) ) + KeyEvent->ignore(); +} + + +void KHexEdit::repaintChanged() +{ + if( !isUpdatesEnabled() || !viewport()->isUpdatesEnabled() || !BufferRanges->isModified() ) + return; + + // TODO: we do this only to let the scrollview handle new or removed lines. overlaps with repaintRange + resizeContents( totalWidth(), totalHeight() ); + + KPixelXs Xs( contentsX(), visibleWidth(), true ); + + // collect affected buffer columns + QPtrList<KBufferColumn> RepaintColumns; + + KBufferColumn *C = ValueColumn; + while( true ) + { + if( C->isVisible() && C->overlaps(Xs) ) + { + RepaintColumns.append( C ); + C->preparePainting( Xs ); + } + + if( C == CharColumn ) + break; + C = CharColumn; + } + + // any colums to paint? + if( RepaintColumns.count() > 0 ) + { + KPixelYs Ys( contentsY(), visibleHeight(), true ); + + // calculate affected lines/indizes + KSection FullPositions( 0, BufferLayout->noOfBytesPerLine()-1 ); + KCoordRange VisibleRange( FullPositions, visibleLines(Ys) ); + + KCoordRange ChangedRange; + // as there might be multiple selections on this line redo until no more is changed + while( hasChanged(VisibleRange,&ChangedRange) ) + { +// std::cout << " changed->"<<FirstChangedIndex<<","<<LastChangedIndex<<std::endl; + + // only one line? + if( ChangedRange.start().line() == ChangedRange.end().line() ) + for( KBufferColumn *C=RepaintColumns.first(); C; C=RepaintColumns.next() ) + paintLine( C, ChangedRange.start().line(), + KSection(ChangedRange.start().pos(),ChangedRange.end().pos()) ); + // + else + { + // first line + for( KBufferColumn *C=RepaintColumns.first(); C; C=RepaintColumns.next() ) + paintLine( C, ChangedRange.start().line(), + KSection(ChangedRange.start().pos(),FullPositions.end()) ); + + // at least one full line? + for( int l = ChangedRange.start().line()+1; l < ChangedRange.end().line(); ++l ) + for( KBufferColumn *C=RepaintColumns.first(); C; C=RepaintColumns.next() ) + paintLine( C, l, FullPositions ); + + // last line + for( KBufferColumn *C=RepaintColumns.first(); C; C=RepaintColumns.next() ) + paintLine( C, ChangedRange.end().line(), + KSection(FullPositions.start(),ChangedRange.end().pos()) ); + } + + // continue the search at the overnext index + VisibleRange.setStart( ChangedRange.end()+2 ); + if( !VisibleRange.isValid() ) + break; + } + } + + + // Paint possible removed bytes at the end of the last line + // Paint new/removed trailing lines +// drawContents( P, cx, cy, cw, ch ); + // Paint empty rects +// paintEmptyArea( P, cx, cy, cw, ch ); +// BufferLayout->noOfLines() + + BufferRanges->resetChangedRanges(); +} + + +void KHexEdit::paintLine( KBufferColumn *C, int Line, KSection Positions ) +{ + Positions.restrictTo( C->visiblePositions() ); + + // nothing to paint? + if( !Positions.isValid() ) + return; +// std::cout << " paintLine->"<<Line<< ":"<<FirstPos<<","<<LastPos<<std::endl; + + // calculating pixel values + KPixelXs XPixels = C->wideXPixelsOfPos( Positions ); + + KPixelY cy = Line * LineHeight; + + // to avoid flickers we first paint to the linebuffer + QPainter Paint; + Paint.begin( &LineBuffer, this ); + + Paint.translate( C->x(), 0 ); + C->paintPositions( &Paint, Line, Positions ); + Paint.translate( -C->x(), 0 ); + + if( HorizontalGrid && XPixels.start() < TotalWidth ) + Paint.drawLine( XPixels.start(), LineHeight-1, XPixels.width(), LineHeight-1 ); // TODO: use a additional TotalHeight? + + Paint.end(); + // copy to screen + bitBlt( viewport(), XPixels.start() - contentsX(), cy - contentsY(), + &LineBuffer, XPixels.start(), 0, XPixels.width(), LineHeight ); +} + + +bool KHexEdit::hasChanged( const KCoordRange &VisibleRange, KCoordRange *ChangedRange ) const +{ + if( !BufferRanges->overlapsChanges(VisibleRange,ChangedRange) ) + return false; + + ChangedRange->restrictTo( VisibleRange ); + return true; +} + + +void KHexEdit::ensureCursorVisible() +{ +// // Not visible or the user is draging the window, so don't position to caret yet +// if ( !isVisible() || isHorizontalSliderPressed() || isVerticalSliderPressed() ) +// { +// d->ensureCursorVisibleInShowEvent = true; +// return; +// } + + KPixelX x = activeColumn().xOfPos( BufferCursor->pos() )+ activeColumn().byteWidth()/2; + KPixelY y = LineHeight * BufferCursor->line() + LineHeight/2; + int xMargin = activeColumn().byteWidth()/2 + 1; + int yMargin = LineHeight/2 + 1; + ensureVisible( x, y, xMargin, yMargin ); +} + + + +void KHexEdit::contentsMousePressEvent( QMouseEvent *e ) +{ +// clearUndoRedo(); + pauseCursor( true ); + + // care about a left button press? + if( e->button() == LeftButton ) + { + MousePressed = true; + + // select whole line? + if( TrippleClickTimer->isActive() + && (e->globalPos()-DoubleClickPoint).manhattanLength() < QApplication::startDragDistance() ) + { + BufferRanges->setSelectionStart( BufferLayout->indexAtLineStart(DoubleClickLine) ); + BufferCursor->gotoLineEnd(); + BufferRanges->setSelectionEnd( BufferCursor->realIndex() ); + repaintChanged(); + + unpauseCursor(); + return; + } + + QPoint MousePoint = e->pos(); + placeCursor( MousePoint ); + ensureCursorVisible(); + + // start of a drag perhaps? + if( BufferRanges->selectionIncludes(BufferCursor->index()) ) + { + DragStartPossible = true; + DragStartTimer->start( QApplication::startDragTime(), true ); + DragStartPoint = MousePoint; + + unpauseCursor(); + return; + } + + int RealIndex = BufferCursor->realIndex(); + if( BufferRanges->selectionStarted() ) + { + if( e->state() & ShiftButton ) + BufferRanges->setSelectionEnd( RealIndex ); + else + { + BufferRanges->removeSelection(); + BufferRanges->setSelectionStart( RealIndex ); + } + } + else // start of a new selection possible + { + BufferRanges->setSelectionStart( RealIndex ); + + if( !isReadOnly() && (e->state()&ShiftButton) ) // TODO: why only for readwrite? + BufferRanges->setSelectionEnd( RealIndex ); + } + + BufferRanges->removeFurtherSelections(); + } + else if( e->button() == MidButton ) + BufferRanges->removeSelection(); + + if( BufferRanges->isModified() ) + { + repaintChanged(); + viewport()->setCursor( isReadOnly() ? arrowCursor : ibeamCursor ); + } + + unpauseCursor(); +} + + +void KHexEdit::contentsMouseMoveEvent( QMouseEvent *e ) +{ + if( MousePressed ) + { + if( DragStartPossible ) + { + DragStartTimer->stop(); + // moved enough for a drag? + if( (e->pos()-DragStartPoint).manhattanLength() > QApplication::startDragDistance() ) + startDrag(); + if( !isReadOnly() ) + viewport()->setCursor( ibeamCursor ); + return; + } + // selecting + QPoint MousePoint = e->pos(); + handleMouseMove( MousePoint ); + } + else if( !isReadOnly() ) + { + // visual feedback for possible dragging + bool InSelection = BufferRanges->hasSelection() && BufferRanges->selectionIncludes( indexByPoint(e->pos()) ); + viewport()->setCursor( InSelection?arrowCursor:ibeamCursor ); + } +} + + +void KHexEdit::contentsMouseReleaseEvent( QMouseEvent *e ) +{ + // this is not the release of a doubleclick so we need to process it? + if( !InDoubleClick ) + { + int Line = lineAt( e->pos().y() ); + int Pos = activeColumn().posOfX( e->pos().x() ); // TODO: can we be sure here about the active column? + int Index = BufferLayout->indexAtCCoord( KBufferCoord(Pos,Line) ); // TODO: can this be another index than the one of the cursor??? + emit clicked( Index ); + } + + if( MousePressed ) + { + MousePressed = false; + + if( ScrollTimer->isActive() ) + ScrollTimer->stop(); + + // was only click inside selection, nothing dragged? + if( DragStartPossible ) + { + selectAll( false ); + DragStartTimer->stop(); + DragStartPossible = false; + + unpauseCursor(); + } + // was end of selection operation? + else if( BufferRanges->hasSelection() ) + { + if( QApplication::clipboard()->supportsSelection() ) + { + ClipboardMode = QClipboard::Selection; + disconnect( QApplication::clipboard(), SIGNAL(selectionChanged()), this, 0); + + copy(); + + connect( QApplication::clipboard(), SIGNAL(selectionChanged()), this, SLOT(clipboardChanged()) ); + ClipboardMode = QClipboard::Clipboard; + } + } + } + // middle mouse button paste? + else if( e->button() == MidButton && !isReadOnly() ) + { + pauseCursor(); + + placeCursor( e->pos() ); + + // replace no selection? + if( BufferRanges->hasSelection() && !BufferRanges->selectionIncludes(BufferCursor->index()) ) + BufferRanges->removeSelection(); + + ClipboardMode = QClipboard::Selection; + paste(); + ClipboardMode = QClipboard::Clipboard; + + // ensure selection changes to be drawn TODO: create a insert/pasteAtCursor that leaves out drawing + repaintChanged(); + + ensureCursorVisible(); + unpauseCursor(); + } + + InDoubleClick = false; + + if( BufferRanges->selectionJustStarted() ) + BufferRanges->removeSelection(); + + emit cursorPositionChanged( BufferCursor->index() ); + + if( !OverWrite ) emit cutAvailable( BufferRanges->hasSelection() ); + emit copyAvailable( BufferRanges->hasSelection() ); + KSection Selection = BufferRanges->selection(); + emit selectionChanged( Selection.start(), Selection.end() ); +} + + +// gets called after press and release instead of a plain press event (?) +void KHexEdit::contentsMouseDoubleClickEvent( QMouseEvent *e ) +{ + // we are only interested in LMB doubleclicks + if( e->button() != Qt::LeftButton ) + { + e->ignore(); + return; + } + + DoubleClickLine = BufferCursor->line(); + + int Index = BufferCursor->validIndex(); + + if( ActiveColumn == &charColumn() ) + { + selectWord( Index ); + + // as we already have a doubleclick maybe it is a tripple click + TrippleClickTimer->start( qApp->doubleClickInterval(), true ); + DoubleClickPoint = e->globalPos(); + } +// else +// ValueEditor->goInsideByte(); TODO: make this possible again + + InDoubleClick = true; // + MousePressed = true; + + emit doubleClicked( Index ); +} + + +void KHexEdit::autoScrollTimerDone() +{ + if( MousePressed ) + handleMouseMove( viewportToContents(viewport()->mapFromGlobal( QCursor::pos() )) ); +} + + +void KHexEdit::handleMouseMove( const QPoint& Point ) // handles the move of the mouse with pressed buttons +{ + // no scrolltimer and outside of viewport? + if( !ScrollTimer->isActive() && Point.y() < contentsY() || Point.y() > contentsY() + visibleHeight() ) + ScrollTimer->start( DefaultScrollTimerPeriod, false ); + // scrolltimer but inside of viewport? + else if( ScrollTimer->isActive() && Point.y() >= contentsY() && Point.y() <= contentsY() + visibleHeight() ) + ScrollTimer->stop(); + + pauseCursor(); + + placeCursor( Point ); + ensureCursorVisible(); + + // do wordwise selection? + if( InDoubleClick && BufferRanges->hasFirstWordSelection() ) + { + int NewIndex = BufferCursor->realIndex(); + KSection FirstWordSelection = BufferRanges->firstWordSelection(); + KWordBufferService WBS( DataBuffer, Codec ); + // are we before the selection? + if( NewIndex < FirstWordSelection.start() ) + { + BufferRanges->ensureWordSelectionForward( false ); + NewIndex = WBS.indexOfLeftWordSelect( NewIndex ); + } + // or behind? + else if( NewIndex > FirstWordSelection.end() ) + { + BufferRanges->ensureWordSelectionForward( true ); + NewIndex = WBS.indexOfRightWordSelect( NewIndex ); + } + // or inside? + else + { + BufferRanges->ensureWordSelectionForward( true ); + NewIndex = FirstWordSelection.end()+1; + } + + BufferCursor->gotoIndex( NewIndex ); + } + + if( BufferRanges->selectionStarted() ) + BufferRanges->setSelectionEnd( BufferCursor->realIndex() ); + + repaintChanged(); + + unpauseCursor(); +} + + +void KHexEdit::startDrag() +{ + // reset states + MousePressed = false; + InDoubleClick = false; + DragStartPossible = false; + + // create data + QDragObject *Drag = dragObject( viewport() ); + if( !Drag ) + return; + + // will we only copy the data? + if( isReadOnly() || OverWrite ) + Drag->dragCopy(); + // or is this left to the user and he choose to move? + else if( Drag->drag() ) + // Not inside this widget itself? + if( QDragObject::target() != this && QDragObject::target() != viewport() ) + removeSelectedData(); +} + + +void KHexEdit::contentsDragEnterEvent( QDragEnterEvent *e ) +{ + // interesting for this widget? + if( isReadOnly() || !KBufferDrag::canDecode(e) ) + { + e->ignore(); + return; + } + + e->acceptAction(); + InDnD = true; +} + + +void KHexEdit::contentsDragMoveEvent( QDragMoveEvent *e ) +{ + // is this content still interesting for us? + if( isReadOnly() || !KBufferDrag::canDecode(e) ) + { + e->ignore(); + return; + } + + // let text cursor follow mouse + pauseCursor( true ); + placeCursor( e->pos() ); + unpauseCursor(); + + e->acceptAction(); +} + + +void KHexEdit::contentsDragLeaveEvent( QDragLeaveEvent * ) +{ + // bye... and thanks for all the cursor movement... + InDnD = false; +} + + + +void KHexEdit::contentsDropEvent( QDropEvent *e ) +{ + // after drag enter and move check one more time + if( isReadOnly() ) + return; + + // leave state + InDnD = false; + e->acceptAction(); + + if( !KBufferDrag::canDecode(e) ) //TODO: why do we acept the action still? + return; + + // is this an internal dnd? + if( e->source() == this || e->source() == viewport() ) + handleInternalDrag( e ); + else + { + //BufferRanges->removeSelection(); + pasteFromSource( e ); + } +} + + +void KHexEdit::handleInternalDrag( QDropEvent *e ) +{ + KSection ChangedRange; + + // stop ui + pauseCursor(); + + // get drag origin + KSection Selection = BufferRanges->selection(); + int InsertIndex = BufferCursor->realIndex(); + + // is this a move? + if( e->action() == QDropEvent::Move ) + { + // ignore the copy hold in the event but only move + int NewIndex = DataBuffer->move( InsertIndex, Selection ); + if( NewIndex != Selection.start() ) + { + BufferCursor->gotoCIndex( NewIndex+Selection.width() ); + ChangedRange.set( QMIN(InsertIndex,Selection.start()), QMAX(InsertIndex,Selection.end()) ); + } + } + // is a copy + else + { + // get data + QByteArray Data; + if( KBufferDrag::decode(e,Data) && !Data.isEmpty() ) + { + if( OverWrite ) + { + if( !BufferCursor->isBehind() ) + { + ChangedRange.setByWidth( InsertIndex, Data.size() ); + ChangedRange.restrictEndTo( BufferLayout->length()-1 ); + if( ChangedRange.isValid() ) + { + int NoOfReplaced = DataBuffer->replace( ChangedRange, Data.data(), ChangedRange.width() ); + BufferCursor->gotoNextByte( NoOfReplaced ); + } + } + } + else + { + int NoOfInserted = DataBuffer->insert( InsertIndex, Data.data(), Data.size() ); + updateLength(); + if( NoOfInserted > 0 ) + { + BufferCursor->gotoCIndex( InsertIndex + NoOfInserted ); + ChangedRange.set( InsertIndex, DataBuffer->size()-1 ); + } + } + } + } + BufferRanges->addChangedRange( ChangedRange ); + BufferRanges->removeSelection(); + + repaintChanged(); + ensureCursorVisible(); + + // open ui + unpauseCursor(); + + // emit appropriate signals. + emit selectionChanged( -1, -1 ); + if( ChangedRange.isValid() ) emit bufferChanged( ChangedRange.start(), ChangedRange.end() ); + emit cursorPositionChanged( BufferCursor->index() ); +} + + +void KHexEdit::contentsWheelEvent( QWheelEvent *e ) +{ + if( isReadOnly() ) + { + if( e->state() & ControlButton ) + { + if( e->delta() > 0 ) + zoomOut(); + else if( e->delta() < 0 ) + zoomIn(); + return; + } + } + QScrollView::contentsWheelEvent( e ); +} + + +#if 0 +void KHexEdit::contentsContextMenuEvent( QContextMenuEvent *e ) +{ +// clearUndoRedo(); + MousePressed = false; + + e->accept(); + + QPopupMenu *PopupMenu = createPopupMenu( e->pos() ); + if( !PopupMenu ) + PopupMenu = createPopupMenu(); + if( !PopupMenu ) + return; + int r = PopupMenu->exec( e->globalPos() ); + delete PopupMenu; + + if ( r == d->id[ IdClear ] ) + clear(); + else if ( r == d->id[ IdSelectAll ] ) + { + selectAll(); + // if the clipboard support selections, put the newly selected text into the clipboard + if( QApplication::clipboard()->supportsSelection() ) + { + ClipboardMode = QClipboard::Selection; + disconnect( QApplication::clipboard(), SIGNAL(selectionChanged()), this, 0); + + copy(); + + connect( QApplication::clipboard(), SIGNAL(selectionChanged()), this, SLOT(clipboardChanged()) ); + ClipboardMode = QClipboard::Clipboard; + } + } + else if( r == d->id[IdUndo] ) + undo(); + else if( r == d->id[IdRedo] ) + redo(); + else if( r == d->id[IdCut] ) + cut(); + else if( r == d->id[IdCopy] ) + copy(); + else if( r == d->id[IdPaste] ) + paste(); +} +#endif + +#include "khexedit.moc" diff --git a/khexedit/lib/khexedit.h b/khexedit/lib/khexedit.h new file mode 100644 index 0000000..66059c8 --- /dev/null +++ b/khexedit/lib/khexedit.h @@ -0,0 +1,562 @@ +/*************************************************************************** + khexedit.h - description + ------------------- + begin : Die Mai 13 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KHEXEDIT_H +#define KHE_KHEXEDIT_H + +// qt specific +#include <qclipboard.h> +// lib specific +// #include "khe.h" +#include "khexedit_export.h" +#include "kcolumnsview.h" + +class QTimer; + +namespace KHE +{ + +class KCoordRange; + +class KDataBuffer; + +class KCharColumn; +class KValueColumn; +class KBufferColumn; +class KOffsetColumn; +class KBorderColumn; + +class KBufferCursor; +class KBufferLayout; +class KBufferRanges; + +class KController; +class KTabController; +class KNavigator; +class KValueEditor; +class KCharEditor; + +class KBufferDrag; + +class KCursor; +class KCharCodec; + +class KHexEditPrivate; + + +/** the main widget + * + * The functions split up in helper functions and those that are complete. + * + * Complete functions can be called from the outside and leave the widget in + * a consistent state. They care for exceptions so one can safely call them in all + * situations (like empty buffer, cursor behind end etc.) + * + * Helper functions do only partial tasks and need to be completed. They often do not + * check for exceptions so one has to care for this. + * + *@author Friedrich W. H. Kossebau + */ + +class KHEXEDIT_EXPORT KHexEdit : public KColumnsView +{ + friend class KTabController; + friend class KNavigator; + friend class KEditor; + friend class KValueEditor; + friend class KCharEditor; + + Q_OBJECT + Q_ENUMS( KResizeStyle KCoding ) + Q_PROPERTY( bool OverwriteMode READ isOverwriteMode WRITE setOverwriteMode ) + Q_PROPERTY( bool OverwriteOnly READ isOverwriteOnly WRITE setOverwriteOnly ) + Q_PROPERTY( bool Modified READ isModified WRITE setModified DESIGNABLE false ) + Q_PROPERTY( bool ReadOnly READ isReadOnly WRITE setReadOnly ) + + Q_PROPERTY( int NoOfBytesPerLine READ noOfBytesPerLine WRITE setNoOfBytesPerLine ) + Q_PROPERTY( bool TabChangesFocus READ tabChangesFocus WRITE setTabChangesFocus ) + + //Q_PROPERTY( bool hasSelectedData READ hasSelectedData ) + //Q_PROPERTY( QByteArray SelectedData READ selectedData ) + Q_PROPERTY( KResizeStyle ResizeStyle READ resizeStyle WRITE setResizeStyle ) + Q_PROPERTY( int StartOffset READ startOffset WRITE setStartOffset ) + Q_PROPERTY( int FirstLineOffset READ firstLineOffset WRITE setFirstLineOffset ) + //_PROPERTY( int undoDepth READ undoDepth WRITE setUndoDepth ) + //_PROPERTY( bool undoRedoEnabled READ isUndoRedoEnabled WRITE setUndoRedoEnabled ) + // value column + Q_PROPERTY( KCoding Coding READ coding WRITE setCoding ) + Q_PROPERTY( int ByteSpacingWidth READ byteSpacingWidth WRITE setByteSpacingWidth ) + Q_PROPERTY( int NoOfGroupedBytes READ noOfGroupedBytes WRITE setNoOfGroupedBytes ) + Q_PROPERTY( int GroupSpacingWidth READ groupSpacingWidth WRITE setGroupSpacingWidth ) + Q_PROPERTY( int BinaryGapWidth READ binaryGapWidth WRITE setBinaryGapWidth ) + // char column + Q_PROPERTY( bool ShowUnprintable READ showUnprintable WRITE setShowUnprintable ) + Q_PROPERTY( QChar SubstituteChar READ substituteChar WRITE setSubstituteChar ) + + public: + enum KResizeStyle { NoResize=0, LockGrouping=1, FullSizeUsage=2, MaxResizeStyleId=0xFF }; + enum KCoding { HexadecimalCoding=0, DecimalCoding=1, OctalCoding=2, BinaryCoding=3, MaxCodingId=0xFFFF }; + enum KEncoding { LocalEncoding=0, ISO8859_1Encoding=1, EBCDIC1047Encoding=2, + StartOfOwnEncoding=0x8000, MaxEncodingId=0xFFFF }; + + enum KBufferColumnId { ValueColumnId=1, CharColumnId=2 }; + + + public: + KHexEdit( KDataBuffer *Buffer = 0, QWidget *Parent = 0, const char *Name = 0, WFlags F = 0 ); + virtual ~KHexEdit(); + + + public: // KColumnsView API + virtual void drawContents( QPainter *p, int cx, int cy, int cw, int ch ); + + public: // QWidget API +// void focusInEvent( QFocusEvent *FocusEvent ); // TODO: why don't these work? +// void focusOutEvent( QFocusEvent *FocusEvent ); + virtual bool eventFilter( QObject *O, QEvent *E ); + + virtual QSize sizeHint() const; + virtual QSize minimumSizeHint() const; + + + public: // value access + /** returns the index of the cursor position */ + int cursorPosition() const; + /***/ + bool isCursorBehind() const; + KBufferColumnId cursorColumn() const; + + bool isOverwriteMode() const; + bool isOverwriteOnly() const; + bool isReadOnly() const; + bool isModified() const; + + bool tabChangesFocus() const; + + KResizeStyle resizeStyle() const; + int noOfBytesPerLine() const; + int startOffset() const; + int firstLineOffset() const; + + bool offsetColumnVisible() const; + int visibleBufferColumns() const; + + // value column + KCoding coding() const; + int/*KPixelX*/ byteSpacingWidth() const; + int noOfGroupedBytes() const; + int/*KPixelX*/ groupSpacingWidth() const; + int/*KPixelX*/ binaryGapWidth() const; + + // char column + /** reports if "unprintable" chars (value<32) are displayed in the char column + * with their original character. Default is false + * @return @c true if original chars are displayed, otherwise @c false + */ + bool showUnprintable() const; + /** gives the used substitute character for "unprintable" chars, default is '.' + * @return substitute character + */ + QChar substituteChar() const; + /** returns the actually used undefined character for "undefined" chars, default is '?' */ + QChar undefinedChar() const; + /** + * @return encoding used in the char column + */ + KEncoding encoding() const; + /** + * @return name of the encoding used in the char column + */ + const QString &encodingName() const; + + public: // logic value service + /** calculates the number of bytes per line that fit into a widget with the given size + * tests whether a vertical scroll bar is needed at all or not due to the given width + * takes the frame width into account + * @param TestSize Size the widget might have + * @return number of bytes per line that fit into a widget with the given size + */ + int fittingBytesPerLine( const QSize &TestSize ) const; + /** detects the index of the byte at the given point + * @param Point in viewport coordinate system + * @return index of the byte that covers the point + */ + int indexByPoint(const QPoint &Point ) const; + + public: + /** returns true if there is a selected range in the array */ + bool hasSelectedData() const; + /** + * @return deep copy of the selected data + */ + QByteArray selectedData() const; + KSection selection() const; + + public: // modification access + /** puts the cursor to the position of index, handles all drawing + * @param Index + */ + void setCursorPosition( int Index, bool Behind=false ); + /** puts the cursor in the column at the pos of Point (in absolute coord), does not handle the drawing */ + void placeCursor( const QPoint &Point ); + /***/ + void setCursorColumn( KBufferColumnId ); +// void repaintByte( int row, int column, bool Erase = true ); +// void updateByte( int row, int column ); +// void ensureByteVisible( int row, int column ); + + public slots: + /** */ + void setDataBuffer( KDataBuffer *B ); + + /** switches the Offset column on/off */ + void toggleOffsetColumn( bool Visible ); + /** */ + void showBufferColumns( int Columns ); + /** scrolls the view as much as needed to have the cursor fully visible */ + void ensureCursorVisible(); + + // setting parameters + /** sets the resizestyle for the value column. Default is KHE::FullSizeUsage */ + void setResizeStyle( KResizeStyle Style ); + /** sets whether the widget is readonly or not, Default is true. + * If the databuffer which is worked on can't be written the widget stays readonly + */ + virtual void setReadOnly( bool b ); + /** sets whether the widget is overwriteonly or not. Default is false. */ + virtual void setOverwriteOnly( bool b ); + /** sets whether the widget is in overwrite mode or not. Default is true. */ + virtual void setOverwriteMode( bool b ); + /** sets whether the data should be treated modified or not */ + virtual void setModified( bool b ); + /** sets whether on a tab key there should be switched from the char column back to the value column + * or be switched to the next focusable widget. Default is false + */ + virtual void setTabChangesFocus( bool b = true ); + // + /** sets the number of bytes per line, switching the resize style to KHE::NoResize */ + virtual void setNoOfBytesPerLine( int NoCpL ); + /** sets absolut offset of the data */ + void setStartOffset( int SO ); + /** sets offset of the char in the upper left corner */ + void setFirstLineOffset( int FLO ); + // value column parameters + /** sets the spacing between the bytes in the value column + * @param BSW spacing between the bytes in pixels + * default is 3 + */ + void setByteSpacingWidth( int/*KPixelX*/ BSW ) ; + /** sets the number of grouped bytes in the value column + * @param NoGB numbers of grouped bytes, 0 means no grouping + * default is 4 + */ + void setNoOfGroupedBytes( int NoGB ); + /** sets the spacing between the groups of bytes in the value column + * @param GSW spacing between the groups in pixels + * default is 9 + */ + void setGroupSpacingWidth( int/*KPixelX*/ GSW ); + /** sets the spacing in the middle of a binary byte in the value column + * @param BinaryGapW spacing in the middle of a binary in pixels + * returns true if there was a change + */ + void setBinaryGapWidth( int BGW ); + /** sets the spacing in the value column + * @param ByteSpacingWidth spacing between the bytes in pixels + * @param NoOfGroupedBytes numbers of grouped bytes, 0 means no grouping + * @param GroupSpacingWidth spacing between the groups in pixels + * Default is 4 for NoOfGroupedBytes + */ + void setBufferSpacing( KPixelX ByteSpacingWidth, int NoOfGroupedBytes = 0, KPixelX GroupSpacingWidth = 0 ); + /** sets the format of the value column. Default is KHE::HexadecimalCoding */ + void setCoding( KCoding C ); + // char column parameters + /** sets whether "unprintable" chars (>32) should be displayed in the char column + * with their corresponding character. + * @param SU + * returns true if there was a change + */ + void setShowUnprintable( bool SU = true ); + /** sets the substitute character for "unprintable" chars + * returns true if there was a change + */ + void setSubstituteChar( QChar SC ); + /** sets the undefined character for "undefined" chars + * returns true if there was a change + */ + void setUndefinedChar( QChar UC ); + /** sets the encoding of the char column. Default is KHE::LocalEncoding. + * If the encoding is not available the format will not be changed. */ + void setEncoding( KEncoding C ); + /** sets the encoding of the char column. Default is KHE::LocalEncoding. + * If the encoding is not available the format will not be changed. + * @param Encoding name of the encoding + */ + void setEncoding( const QString& Encoding ); + + // interaction + /** de-/selects all data */ + void selectAll( bool select ); + /** de-/selects all data */ + void select( KSection S ); + /** selects word at index, returns true if there is one */ + bool selectWord( /*unsigned*/ int Index /*, Chartype*/ ); + /** removes the selected data, takes care of the cursor */ + virtual void removeSelectedData(); + /** inserts */ + virtual void insert( const QByteArray &D ); + + // clipboard interaction + virtual void copy(); + virtual void cut(); + virtual void paste(); + + // zooming + virtual void zoomIn( int PointInc ); + virtual void zoomIn(); + virtual void zoomOut( int PointInc ); + virtual void zoomOut(); + virtual void zoomTo( int PointSize ); + virtual void unZoom(); + + // cursor control + /** we have focus again, start the timer */ + virtual void startCursor(); + /** we lost focus, stop the timer */ + virtual void stopCursor(); + /** simply pauses any blinking, i.e. ignores any calls to blinkCursor */ + virtual void pauseCursor( bool LeaveEdit = false ); + /** undoes pauseCursor */ + virtual void unpauseCursor(); + + + signals: + /** Index of the byte that was clicked */ + void clicked( int Index ); + /** Index of the byte that was double clicked */ + void doubleClicked( int Index ); + + void cursorPositionChanged( int Index ); + /** selection has changed */ + void selectionChanged( int StartIndex, int EndIndex ); + /** there is a cut available or not */ + void cutAvailable( bool Really ); + /** there is a copy available or not */ + void copyAvailable( bool Really ); + /** there has been a change to the buffer */ + void bufferChanged( int StartIndex, int EndIndex ); + + + protected: // QWidget API + virtual void keyPressEvent( QKeyEvent *KeyEvent ); + virtual void resizeEvent( QResizeEvent *ResizeEvent ); + virtual void showEvent( QShowEvent *e ); + + protected: // QScrollView API + virtual void contentsMousePressEvent( QMouseEvent *e ); + virtual void contentsMouseReleaseEvent( QMouseEvent * e ); + virtual void contentsMouseMoveEvent( QMouseEvent *e ); + virtual void contentsMouseDoubleClickEvent( QMouseEvent * e ); + virtual void contentsDragEnterEvent( QDragEnterEvent *e ); + virtual void contentsDragMoveEvent( QDragMoveEvent *e ); + virtual void contentsDragLeaveEvent( QDragLeaveEvent * ); + virtual void contentsDropEvent( QDropEvent *e ); + virtual void contentsWheelEvent( QWheelEvent *e ); +// virtual void contentsContextMenuEvent( QContextMenuEvent *e ); + + protected: // KColumnsView API + virtual void setNoOfLines( int NewNoOfLines ); + + + protected: // element accessor functions + KValueColumn& valueColumn(); + KCharColumn& charColumn(); + KBufferColumn& activeColumn(); + KBufferColumn& inactiveColumn(); + const KValueColumn& valueColumn() const; + const KCharColumn& charColumn() const; + const KBufferColumn& activeColumn() const; + const KBufferColumn& inactiveColumn() const; + + protected: // atomic ui operations + /** handles screen update in case of a change to any of the width sizes + */ + void updateViewByWidth(); + /** repaints all the parts that are signed as changed */ + void repaintChanged(); + + protected: // drawing related operations + /** recreates the cursor pixmaps and paints active and inactive cursors if doable */ + void updateCursor(); + void createCursorPixmaps(); + void pointPainterToCursor( QPainter &Painter, const KBufferColumn &Column ) const; + /** draws the blinking cursor or removes it */ + void paintActiveCursor( bool CursorOn ); + void paintInactiveCursor( bool CursorOn ); + void paintLine( KBufferColumn *C, int Line, KSection Positions ); + + protected: // partial operations + void handleMouseMove( const QPoint& Point ); + KBufferDrag *dragObject( QWidget *Parent = 0 ) const; + void pasteFromSource( QMimeSource *Source ); + /** removes the section from the databuffer and updates all affected values */ + KSection removeData( KSection Indizes ); + /** sets ChangedRange to the range of VisibleRange that is actually changed + * @return true if there was a change within the visible range + */ + bool hasChanged( const KCoordRange &VisibleRange, KCoordRange *ChangedRange ) const; + void handleInternalDrag( QDropEvent *e ); + + protected: + /** recalcs all dependant values with the actual NoOfBytesPerLine */ + void adjustToLayoutNoOfBytesPerLine(); + /** recalcs a layout due to the resize style that fits into the view size + * and updates the dependant values + */ + void adjustLayoutToSize(); + /** */ + void updateLength(); + /** calls updateContent for the Column */ + void updateColumn( KColumn &Column ); + + protected slots: + /** gets called by the cursor blink timer */ + void blinkCursor(); + /** gets called by the scroll timer (for mouse selection) */ + void autoScrollTimerDone(); + /** */ + void clipboardChanged(); + /** */ + void startDrag(); + + protected slots: // QWidget API + virtual void fontChange( const QFont &OldFont ); + + + protected: + /** Buffer with the data */ + KDataBuffer *DataBuffer; + + /** holds the logical layout */ + KBufferLayout *BufferLayout; + /** */ + KBufferCursor *BufferCursor; + /** */ + KBufferRanges *BufferRanges; + + + protected: + KOffsetColumn *OffsetColumn; + KBorderColumn *FirstBorderColumn; + KValueColumn *ValueColumn; + KBorderColumn *SecondBorderColumn; + KCharColumn *CharColumn; + + /** points to the column with keyboard focus */ + KBufferColumn *ActiveColumn; + /** points to the column without keyboard focus (if there is) */ + KBufferColumn *InactiveColumn; + + /** the actual input controller */ + KController *Controller; + /** */ + KTabController *TabController; + /** */ + KNavigator *Navigator; + /** */ + KValueEditor *ValueEditor; + /** */ + KCharEditor *CharEditor; + + protected: + /** Timer that controls the blinking of the cursor */ + QTimer *CursorBlinkTimer; + /** Timer that triggers ensureCursorVisible function calls */ + QTimer *ScrollTimer; +/* QTimer *ChangeIntervalTimer, */ + /** Timer to start a drag */ + QTimer *DragStartTimer; + /** timer to measure whether the time between a double click and the following counts for a tripleclick */ + QTimer *TrippleClickTimer; + + /** object to store the blinking cursor pixmaps */ + KCursor *CursorPixmaps; + /** */ + KCharCodec *Codec; + + protected: + /** point at which the current double click happended (used by TrippleClick) */ + QPoint DoubleClickPoint; + /** line in which the current double click happended (used by TrippleClick) */ + int DoubleClickLine; + /** point at which the current dragging started */ + QPoint DragStartPoint; + /** */ + QClipboard::Mode ClipboardMode; + /** font size as set by user (used for zooming) */ + int DefaultFontSize; + + protected: // parameters + /** style of resizing */ + KResizeStyle ResizeStyle; + /** */ + KEncoding Encoding; + + /** flag whether the widget is set to readonly. Cannot override the databuffer's setting, of course. */ + bool ReadOnly:1; + /** flag if only overwrite is allowed */ + bool OverWriteOnly:1; + /** flag if overwrite mode is active */ + bool OverWrite:1; + /** flag if a mouse button is pressed */ + bool MousePressed:1; + /** flag if a double click is happening */ + bool InDoubleClick:1; + /** flag if a Drag'n'Drop is happening */ + bool InDnD:1; + /** flag if a drag might have started */ + bool DragStartPossible:1; + /** flag if the cursor should be invisible */ + bool CursorPaused:1; + /** flag if the cursor is visible */ + bool BlinkCursorVisible:1; + /** flag whether the font is changed due to a zooming */ + bool InZooming:1; + + private: + /** the binary compatibility saving helper */ + KHexEditPrivate* d; + + private: // Disabling copy constructor and operator= - not useful + KHexEdit( const KHexEdit & ); + KHexEdit &operator=( const KHexEdit & ); +}; + + +inline const KValueColumn& KHexEdit::valueColumn() const { return *ValueColumn; } +inline const KCharColumn& KHexEdit::charColumn() const { return *CharColumn; } +inline const KBufferColumn& KHexEdit::activeColumn() const { return *ActiveColumn; } +inline const KBufferColumn& KHexEdit::inactiveColumn() const { return *InactiveColumn; } + +inline KValueColumn& KHexEdit::valueColumn() { return *ValueColumn; } +inline KCharColumn& KHexEdit::charColumn() { return *CharColumn; } +inline KBufferColumn& KHexEdit::activeColumn() { return *ActiveColumn; } +inline KBufferColumn& KHexEdit::inactiveColumn() { return *InactiveColumn; } + +} + +#endif diff --git a/khexedit/lib/khexedit_export.h b/khexedit/lib/khexedit_export.h new file mode 100644 index 0000000..f922516 --- /dev/null +++ b/khexedit/lib/khexedit_export.h @@ -0,0 +1,25 @@ +/*************************************************************************** + khexedit_export.h - description + ------------------- + begin : 22 Nov 2004 + copyright : (C) 2004 Dirk Mueller + email : mueller@kde.org + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHEXEDIT_EXPORT_H +#define KHEXEDIT_EXPORT_H + +#include <kdemacros.h> + +#define KHEXEDIT_EXPORT KDE_EXPORT + +#endif diff --git a/khexedit/lib/koffsetcoltextexport.cpp b/khexedit/lib/koffsetcoltextexport.cpp new file mode 100644 index 0000000..c5644df --- /dev/null +++ b/khexedit/lib/koffsetcoltextexport.cpp @@ -0,0 +1,61 @@ +/*************************************************************************** + koffsetcoltextexport.cpp - description + ------------------- + begin : Sam Aug 30 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// qt specific +#include <qstring.h> +// lib specific +#include "koffsetcolumn.h" +#include "koffsetcoltextexport.h" + +using namespace KHE; + + +KOffsetColTextExport::KOffsetColTextExport( const KOffsetColumn *OffsetColumn ) + : CodingWidth( OffsetColumn->codingWidth() ), + FirstLineOffset( OffsetColumn->firstLineOffset() ), + Delta( OffsetColumn->delta() ), + printFunction( OffsetColumn->printFunction() ) +{ +} + +int KOffsetColTextExport::charsPerLine() const +{ + return CodingWidth; +} + + +void KOffsetColTextExport::printFirstLine( QString &T, int Line ) const +{ + PrintLine = Line; + print( T ); +} + +void KOffsetColTextExport::printNextLine( QString &T ) const +{ + print( T ); +} + +void KOffsetColTextExport::print( QString &T ) const +{ + // TODO: fix me (no more printFunction) + char *B = new char[CodingWidth+1]; + printFunction( B, FirstLineOffset + Delta*PrintLine ); + T.append( B ); + delete [] B; + + ++PrintLine; +} diff --git a/khexedit/lib/koffsetcoltextexport.h b/khexedit/lib/koffsetcoltextexport.h new file mode 100644 index 0000000..e07e659 --- /dev/null +++ b/khexedit/lib/koffsetcoltextexport.h @@ -0,0 +1,57 @@ +/*************************************************************************** + koffsetcoltextexport.h - description + ------------------- + begin : Sam Aug 30 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KOFFSETCOLTEXTEXPORT_H +#define KHE_KOFFSETCOLTEXTEXPORT_H + +// lib specific +#include "kcoltextexport.h" +#include "koffsetformat.h" + + +namespace KHE +{ + +class KOffsetColumn; + +class KOffsetColTextExport : public KColTextExport +{ + public: + KOffsetColTextExport( const KOffsetColumn *OC ); + + public: // KColTextExport API + void printFirstLine( QString &T, int Line ) const; + void printNextLine( QString &T ) const; + /** tells how much chars per line are needed */ + int charsPerLine() const; + + protected: + void print( QString &T ) const; + + protected: + const int CodingWidth; + const int FirstLineOffset; + const int Delta; + const KOffsetFormat::print printFunction; + + /** the line we are in */ + mutable int PrintLine; +}; + +} + +#endif diff --git a/khexedit/lib/koffsetcolumn.cpp b/khexedit/lib/koffsetcolumn.cpp new file mode 100644 index 0000000..6bd6d09 --- /dev/null +++ b/khexedit/lib/koffsetcolumn.cpp @@ -0,0 +1,110 @@ +/*************************************************************************** + koffsetcolumn.cpp - description + ------------------- + begin : Mit Mai 14 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + +// qt specific +#include "qpainter.h" +// lib specific +#include "kcolumnsview.h" +#include "koffsetcolumn.h" + +using namespace KHE; + +KOffsetColumn::KOffsetColumn( KColumnsView *V, int FLO, int D, KOffsetFormat::KFormat F ) + : KColumn( V ), + FirstLineOffset( FLO ), + Delta( D ), + Margin( 0 ), + DigitWidth( 0 ), + DigitBaseLine( 0 ), + Format( KOffsetFormat::None ) +{ + setFormat( F ); +} + + +KOffsetColumn::~KOffsetColumn() +{ +} + + +void KOffsetColumn::paintLine( QPainter *P, int Line ) +{ + const QColor &ButtonColor = View->colorGroup().button(); + P->fillRect( 0,0,width(),LineHeight, QBrush(ButtonColor,Qt::SolidPattern) ); + + printFunction()( CodedOffset,FirstLineOffset+Delta*Line ); + P->drawText( 0, DigitBaseLine, QString().append(CodedOffset) ); +} + + +void KOffsetColumn::paintFirstLine( QPainter *P, KPixelXs, int FirstLine ) +{ + PaintLine = FirstLine; + paintLine( P, PaintLine++ ); +} + + +void KOffsetColumn::paintNextLine( QPainter *P ) +{ + paintLine( P, PaintLine++ ); +} + + + +void KOffsetColumn::paintEmptyColumn( QPainter *P, KPixelXs Xs, KPixelYs Ys ) +{ + Xs.restrictTo( XSpan ); + + const QColor &ButtonColor = View->colorGroup().button(); + P->fillRect( Xs.start(), Ys.start(), Xs.width(), Ys.width(), QBrush(ButtonColor,Qt::SolidPattern) ); +} + +void KOffsetColumn::setFormat( KOffsetFormat::KFormat F ) +{ + // no changes? + if( Format == F ) + return; + + Format = F; + + CodingWidth = KOffsetFormat::codingWidth( Format ); + PrintFunction = KOffsetFormat::printFunction( Format ); + + recalcX(); +} + +void KOffsetColumn::setMetrics( KPixelX DW, KPixelY DBL ) +{ + DigitBaseLine = DBL; + setDigitWidth( DW ); +} + +void KOffsetColumn::setDigitWidth( KPixelX DW ) +{ + // no changes? + if( DigitWidth == DW ) + return; + + DigitWidth = DW; + + recalcX(); +} + +void KOffsetColumn::recalcX() +{ + // recalculate depend sizes + setWidth( CodingWidth * DigitWidth ); +} diff --git a/khexedit/lib/koffsetcolumn.h b/khexedit/lib/koffsetcolumn.h new file mode 100644 index 0000000..ae182f9 --- /dev/null +++ b/khexedit/lib/koffsetcolumn.h @@ -0,0 +1,109 @@ +/*************************************************************************** + koffsetcolumn.h - description + ------------------- + begin : Mit Mai 14 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KOFFSETCOLUMN_H +#define KHE_KOFFSETCOLUMN_H + +// lib specific +#include "koffsetformat.h" +#include "kcolumn.h" + +namespace KHE +{ + +/** + *@author Friedrich W. H. Kossebau + */ + +class KOffsetColumn : public KColumn +{ + public: + KOffsetColumn( KColumnsView *V, int FLO, int D, KOffsetFormat::KFormat F ); + virtual ~KOffsetColumn(); + + public: // KColumn API + virtual void paintFirstLine( QPainter *P, KPixelXs Xs, int FirstLine ); + virtual void paintNextLine( QPainter *P ); + virtual void paintEmptyColumn( QPainter *P, KPixelXs Xs, KPixelYs Ys ); + + + public: + void setFirstLineOffset( int FLO ); + void setDelta( int D ); + + void setFormat( KOffsetFormat::KFormat F ); + /** sets width of digits and recalculates depend sizes */ + void setDigitWidth( KPixelX DW ); + /** */ + void setMetrics( KPixelX DW, KPixelY DBL ); + + public: // read access + int delta() const; + int firstLineOffset() const; + int codingWidth() const; + KOffsetFormat::print printFunction() const; + + + protected: + /** recalculates all x values */ + void recalcX(); + /** paints full line */ + void paintLine( QPainter *P, int Line ); + + + protected: // user settings + /** starting offset of the first line + * if different from StartOffset results in leading space + */ + int FirstLineOffset; + /** offset delta per line */ + int Delta; + + protected: // pixel related + /** size of the line margin */ + int Margin; + /** */ + KPixelX DigitWidth; + /** */ + KPixelY DigitBaseLine; + + protected: // general layout + KOffsetFormat::KFormat Format; + + int CodingWidth; + KOffsetFormat::print PrintFunction; + + /** buffer to hold the formatted coding */ + mutable char CodedOffset[KOffsetFormat::MaxFormatWidth+1]; + + protected: // firstnext trips related + /** */ + int PaintLine; +}; + + +inline int KOffsetColumn::firstLineOffset() const { return FirstLineOffset; } +inline void KOffsetColumn::setFirstLineOffset( int FLO ) { FirstLineOffset = FLO; } +inline int KOffsetColumn::delta() const { return Delta; } +inline void KOffsetColumn::setDelta( int D ) { Delta = D; } + +inline int KOffsetColumn::codingWidth() const { return CodingWidth; } +inline KOffsetFormat::print KOffsetColumn::printFunction() const { return PrintFunction; } + +} + +#endif diff --git a/khexedit/lib/koffsetformat.cpp b/khexedit/lib/koffsetformat.cpp new file mode 100644 index 0000000..e82fa9d --- /dev/null +++ b/khexedit/lib/koffsetformat.cpp @@ -0,0 +1,48 @@ +/*************************************************************************** + koffsetformat.cpp - description + ------------------- + begin : Mit Mai 21 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// c specific +#include <stdio.h> +// lib specific +#include "koffsetformat.h" + +using namespace KHE; + + +const unsigned int KOffsetFormat::CodingWidth[2] = { 9, 10 }; + +const KOffsetFormat::print KOffsetFormat::PrintFunction[2] = +{ KOffsetFormat::printHexadecimalOffset, KOffsetFormat::printDecimalOffset }; + + + +void KOffsetFormat::printHexadecimalOffset( char *Buffer, unsigned int Offset ) +{ + sprintf( Buffer, "%04X:%04X", Offset>>16, Offset&0x0000FFFF ); +} + + +void KOffsetFormat::printHexadecimalSmallOffset( char *Buffer, unsigned int Offset ) +{ + sprintf( Buffer, "%04x:%04x", Offset>>16, Offset&0x0000FFFF ); +} + + +void KOffsetFormat::printDecimalOffset( char *Buffer, unsigned int Offset ) +{ + sprintf( Buffer, "%010u", Offset ); +} diff --git a/khexedit/lib/koffsetformat.h b/khexedit/lib/koffsetformat.h new file mode 100644 index 0000000..8bd90e2 --- /dev/null +++ b/khexedit/lib/koffsetformat.h @@ -0,0 +1,70 @@ +/*************************************************************************** + koffsetformat.h - description + ------------------- + begin : Mit Mai 21 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KOFFSETFORMAT_H +#define KHE_KOFFSETFORMAT_H + +namespace KHE +{ + +/** + *@author Friedrich W. H. Kossebau + */ + +class KOffsetFormat +{ + public: + /** */ + typedef void (*print)( char *Buffer, unsigned int Offset ); + /** */ + enum KFormat { Hexadecimal=0, Decimal, None }; + /** */ + static const int MaxFormatWidth = 9; + + private: + KOffsetFormat(); + ~KOffsetFormat(); + + public: + /** */ + static unsigned int codingWidth( int i ); + /** */ + static print printFunction( int i ); + + public: + static void printHexadecimalOffset( char *Buffer, unsigned int Offset ); + static void printHexadecimalSmallOffset( char *Buffer, unsigned int Offset ); + static void printDecimalOffset( char *Buffer, unsigned int Offset ); + + protected: + /** */ + static const unsigned int CodingWidth[2]; //TODO: would sizeof(Coding} work? + /** */ + static const print PrintFunction[2]; +}; + + +inline unsigned int KOffsetFormat::codingWidth( int i ) +{ return CodingWidth[i]; } + +inline KOffsetFormat::print KOffsetFormat::printFunction( int i ) +{ return PrintFunction[i]; } + + +} + +#endif diff --git a/khexedit/lib/kplainbuffer.cpp b/khexedit/lib/kplainbuffer.cpp new file mode 100644 index 0000000..63c1db7 --- /dev/null +++ b/khexedit/lib/kplainbuffer.cpp @@ -0,0 +1,344 @@ +/*************************************************************************** + kplainbuffer.cpp - description + ------------------- + begin : Mit Jun 03 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + +//#include <kdebug.h> +// c specific +#include <string.h> +#include <stdlib.h> +// lib specific +#include "kplainbuffer.h" + + +static const unsigned int MinChunkSize = 512; +static const unsigned int MaxChunkSize = 1024*10; // TODO: get max. memory page size + +// TODO: think about realloc & Co. +using namespace KHE; + +KPlainBuffer::KPlainBuffer( char *D, unsigned int S, int RS, bool KM ) + : Data( D ), + Size( S ), + RawSize( RS<(int)S?S:RS ), + MaxSize( -1 ), + KeepsMemory( KM ), + ReadOnly( true ), + Modified( false ) +{ +} + +KPlainBuffer::KPlainBuffer( const char *D, unsigned int S ) + : Data( (char *)D ), + Size( S ), + RawSize( S ), + MaxSize( -1 ), + KeepsMemory( true ), + ReadOnly( true ), + Modified( false ) +{ +} + +KPlainBuffer::KPlainBuffer( int S, int MS ) + : Data( S?new char[S]:0 ), + Size( S ), + RawSize( S ), + MaxSize( MS ), + KeepsMemory( false ), + ReadOnly( true ), + Modified( false ) +{ +} + +KPlainBuffer::~KPlainBuffer() +{ +} + + + +int KPlainBuffer::insert( int Pos, const char* D, int Length ) +{ + // check all parameters + if( Length == 0 ) + return 0; + //kdDebug() << QString("before: Size: %1, RawSize: %2").arg(Size).arg(RawSize) << endl; + // correct for appending + if( Pos > (int)Size ) + Pos = Size; + + Length = addSize( Length, Pos, true ); + + // copy new data to its place + memcpy( &Data[Pos], D, Length ); + + //kdDebug() << QString("after: Size: %1, RawSize: %2").arg(Size).arg(RawSize) << endl; + + Modified = true; + return Length; +} + + +int KPlainBuffer::remove( KSection Remove ) +{ + if( Remove.startsBehind(Size-1) || Remove.width() == 0 ) + return 0; + + Remove.restrictEndTo( Size-1 ); + + unsigned int BehindRemovePos = Remove.end()+1; + // move right data behind the input range + memmove( &Data[Remove.start()], &Data[BehindRemovePos], Size-BehindRemovePos ); + + // set new values + Size -= Remove.width(); + + Modified = true; + return Remove.width(); +} + + +unsigned int KPlainBuffer::replace( KSection Remove, const char* D, unsigned int InputLength ) +{ + // check all parameters + if( Remove.start() >= (int)Size || (Remove.width()==0 && InputLength==0) ) + return 0; + + Remove.restrictEndTo( Size-1 ); + + int SizeDiff = InputLength - Remove.width(); + unsigned int NewSize = Size + SizeDiff; + // check if buffer does not get to big TODO: make algo simplier and less if else + if( MaxSize != -1 && (int)NewSize > MaxSize) + { + if( (int)Size == MaxSize ) + return 0; + InputLength -= NewSize - MaxSize; + NewSize = MaxSize; + } + else if( KeepsMemory && NewSize > RawSize ) + { + if( Size == RawSize ) + return 0; + InputLength -= NewSize - RawSize; + NewSize = RawSize; + } + + int BehindInsertPos = Remove.start() + InputLength; + int BehindRemovePos = Remove.end()+1; + + // raw array not big enough? + if( RawSize < NewSize ) + { + // create new buffer + char *NewData = new char[NewSize]; + if( NewData == 0 ) + return 0; + + // move old data to its (new) places + memcpy( NewData, Data, Remove.start() ); + memcpy( &NewData[BehindInsertPos], &Data[BehindRemovePos], Size-BehindRemovePos ); + + // remove old + delete [] Data; + // set new values + Data = NewData; + RawSize = NewSize; + } + else + // move old data to its (new) places + memmove( &Data[BehindInsertPos], &Data[BehindRemovePos], Size-BehindRemovePos ); + + // copy new data to its place + memcpy( &Data[Remove.start()], D, InputLength ); + + // set new values + Size = NewSize; + + Modified = true; + return InputLength; +} + + +int KPlainBuffer::move( int DestPos, KSection SourceSection ) +{ + // check all parameters + if( SourceSection.start() >= (int)Size || SourceSection.width() == 0 + || DestPos > (int)Size || SourceSection.start() == DestPos ) + return SourceSection.start(); + + SourceSection.restrictEndTo( Size-1 ); + bool ToRight = DestPos > SourceSection.start(); + int MovedLength = SourceSection.width(); + int DisplacedLength = ToRight ? DestPos - SourceSection.end()-1 : SourceSection.start() - DestPos; + + // find out section that is smaller + int SmallPartLength, LargePartLength, SmallPartStart, LargePartStart, SmallPartDest, LargePartDest; + // moving part is smaller? + if( MovedLength < DisplacedLength ) + { + SmallPartStart = SourceSection.start(); + SmallPartLength = MovedLength; + LargePartLength = DisplacedLength; + // moving part moves right? + if( ToRight ) + { + SmallPartDest = DestPos - MovedLength; + LargePartStart = SourceSection.end()+1; + LargePartDest = SourceSection.start(); + } + else + { + SmallPartDest = DestPos; + LargePartStart = DestPos; + LargePartDest = DestPos + MovedLength; + } + } + else + { + LargePartStart = SourceSection.start(); + LargePartLength = MovedLength; + SmallPartLength = DisplacedLength; + // moving part moves right? + if( ToRight ) + { + LargePartDest = DestPos - MovedLength; + SmallPartStart = SourceSection.end()+1; + SmallPartDest = SourceSection.start(); + } + else + { + LargePartDest = DestPos; + SmallPartStart = DestPos; + SmallPartDest = DestPos + MovedLength; + } + } + + // copy smaller part to tempbuffer + char *Temp = new char[SmallPartLength]; + memcpy( Temp, &Data[SmallPartStart], SmallPartLength ); + + // move the larger part + memmove( &Data[LargePartDest], &Data[LargePartStart], LargePartLength ); + + // copy smaller part to its new dest + memcpy( &Data[SmallPartDest], Temp, SmallPartLength ); + delete [] Temp; + + Modified = true; + return MovedLength < DisplacedLength ? SmallPartDest : LargePartDest; +} + + +int KPlainBuffer::fill( const char FChar, int FillLength, unsigned int Pos ) +{ + // nothing to fill + if( Pos >= Size ) + return 0; + + int LengthToEnd = Size - Pos; + + if( FillLength < 0 ) + FillLength = LengthToEnd; + else if( FillLength > LengthToEnd ) + FillLength = addSize( FillLength, Pos, false ); + + memset( &Data[Pos], FChar, FillLength ); + Modified = true; + return FillLength; +} + + +int KPlainBuffer::find( const char* SearchString, int Length, KSection Section ) const +{ + Section.restrictEndTo( Size-1 ); + + for( int i = Section.start(); i <= Section.end(); ++i ) + { + int Result; +// if( IgnoreCase ) +// result = strncasecmp( &data()[i], sc.key.data(), sc.key.size() ); +// else + Result = memcmp( &Data[i], SearchString, Length ); + // found? + if( Result == 0 ) + return i; + } + return -1; +} + +int KPlainBuffer::rfind( const char*, int /*Length*/, int /*Pos*/ ) const { return 0; } + + +int KPlainBuffer::addSize( int AddSize, int SplitPos, bool SaveUpperPart ) +{ + unsigned int NewSize = Size + AddSize; + // check if buffer does not get too big + if( MaxSize != -1 && (int)NewSize > MaxSize ) + { + if( (int)Size == MaxSize ) + return 0; + NewSize = MaxSize; + AddSize = NewSize - Size; + } + else if( KeepsMemory && NewSize > RawSize ) + { + if( Size == RawSize ) + return 0; + NewSize = RawSize; + AddSize = NewSize - Size; + } + + int BehindSplitPos = SplitPos + AddSize; + // raw array not big enough? + if( RawSize < NewSize ) + { + // get new raw size + unsigned int ChunkSize = MinChunkSize; + // find chunk size where newsize fits into + while( ChunkSize < NewSize ) + ChunkSize <<= 1; + // limit to max size + if( ChunkSize > MaxChunkSize ) + ChunkSize = MaxChunkSize; + // find add size + unsigned int NewRawSize = ChunkSize; + while( NewRawSize<NewSize ) + NewRawSize += ChunkSize; + // create new buffer + char *NewData = new char[NewRawSize]; + + // move old data to its (new) places + memcpy( NewData, Data, SplitPos ); + if( SaveUpperPart ) + memcpy( &NewData[BehindSplitPos], &Data[SplitPos], Size-SplitPos ); + + // remove old + delete [] Data; + // set new values + Data = NewData; + RawSize = NewRawSize; + } + // old buffer kept + else + { + if( SaveUpperPart ) + // move old data to its (new) places + memmove( &Data[BehindSplitPos], &Data[SplitPos], Size-SplitPos ); + } + + // set new values + Size = NewSize; + + return AddSize; +} diff --git a/khexedit/lib/kplainbuffer.h b/khexedit/lib/kplainbuffer.h new file mode 100644 index 0000000..27bbbad --- /dev/null +++ b/khexedit/lib/kplainbuffer.h @@ -0,0 +1,131 @@ +/*************************************************************************** + kplainbuffer.h - description + ------------------- + begin : Mit Jun 03 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KPLAINBUFFER_H +#define KHE_KPLAINBUFFER_H + +#include "kdatabuffer.h" + +namespace KHE +{ +/* +class KPlainBufferIterator : public KDataBufferIterator +{ +} +*/ +/** base class for all Data buffers that are used to display + * TODO: think about a way to inform KHexEdit that there has been + * a change in the buffer outside. what kind of changes are possible? + *@author Friedrich W. H. Kossebau + */ + +class KPlainBuffer : public KDataBuffer +{ + friend class KPlainBufferIterator; + + public: + KPlainBuffer( char *D, unsigned int S, int RS = -1, bool KM = true ); + KPlainBuffer( const char *D, unsigned int S ); + KPlainBuffer( int S=0, int MS = -1 ); + virtual ~KPlainBuffer(); + + public: // KDataBuffer API + virtual bool prepareRange( KSection Range ) const; + //virtual KDataBufferIterator *iterator() const; + virtual const char *dataSet( KSection S ) const; + virtual char datum( unsigned int Offset ) const; + virtual int size() const; + virtual bool isReadOnly() const; + virtual bool isModified() const; + + virtual int insert( int Pos, const char*, int Length ); + virtual int remove( KSection Remove ); + virtual unsigned int replace( KSection Remove, const char*, unsigned int InputLength ); + virtual int move( int DestPos, KSection SourceSection ); + virtual int fill( const char FillChar, int Length = -1, unsigned int Pos = 0 ); + virtual void setDatum( unsigned int Offset, const char Char ); + + virtual void setModified( bool M = true ); + + //virtual int find( const char*, int Length, int Pos = 0 ) const; + virtual int find( const char*KeyData, int Length, KSection Section ) const; + virtual int rfind( const char*, int Length, int Pos = -1 ) const; + +/* virtual int find( const QString &expr, bool cs, bool wo, bool forward = true, int *index = 0 ); */ + + public: + void setReadOnly( bool RO = true ); + void setMaxSize( int MS ); + /** sets whether the memory given by setData or in the constructor should be kept on resize + */ + void setKeepsMemory( bool KM = true ); + + public: + char *data() const; + int maxSize() const; + /** returns whether the memory of the byte array is kept */ + bool keepsMemory() const; + + protected: + /** resizes the buffer, if possible, saving the data and splitting the data, if demanded + * @param AddSize additional size the buffer should grow + * @param SplitPos if -1 does not split + * @param SaveUpperPart true if upper part should be copied into new buffer + * @return additional size the buffer has grown + */ + int addSize( int AddSize, int SplitPos = -1, bool SaveUpperPart = true ); + + protected: + /** */ + char *Data; + /** size of the data */ + unsigned int Size; + /** Size of data array */ + unsigned int RawSize; + /** maximal size of array, unlimited if -1 */ + int MaxSize; + /** flag whether the initially given memory should be kept */ + bool KeepsMemory:1; + /** */ + bool ReadOnly:1; + /** */ + bool Modified:1; +}; + + +inline bool KPlainBuffer::prepareRange( KSection ) const { return true; } +inline const char *KPlainBuffer::dataSet( KSection S ) const { return &Data[S.start()]; } +inline char KPlainBuffer::datum( unsigned int Offset ) const { return Data[Offset]; } +inline int KPlainBuffer::size() const { return Size; } + +inline bool KPlainBuffer::isReadOnly() const { return ReadOnly; } +inline bool KPlainBuffer::isModified() const { return Modified; } + +inline void KPlainBuffer::setDatum( unsigned int Offset, const char Char ) +{ Data[Offset] = Char; Modified = true; } + +inline void KPlainBuffer::setReadOnly( bool RO ) { ReadOnly = RO; } +inline void KPlainBuffer::setModified( bool M ) { Modified = M; } +inline void KPlainBuffer::setMaxSize( int MS ) { MaxSize = MS; } +inline void KPlainBuffer::setKeepsMemory( bool KM ) { KeepsMemory = KM; } + +inline char *KPlainBuffer::data() const { return Data; } +inline int KPlainBuffer::maxSize() const { return MaxSize; } +inline bool KPlainBuffer::keepsMemory() const { return KeepsMemory; } +} + +#endif diff --git a/khexedit/lib/krange.h b/khexedit/lib/krange.h new file mode 100644 index 0000000..a0df3f1 --- /dev/null +++ b/khexedit/lib/krange.h @@ -0,0 +1,123 @@ +/*************************************************************************** + krange.h - description + ------------------- + begin : Sun 03.08.2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de +****************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KRANGE_H +#define KHE_KRANGE_H + + +namespace KHE +{ + +/** This template describes a range. + * A range is something with a start and an end. + * The start is a value relative before the end. + * The distance cannot be estimated. + * + *@author Friedrich W. H. Kossebau + */ +template<class T> +class KRange +{ + public: + KRange( T S, T E ) : Start( S ), End( E ) {} + KRange() : Start( null() ), End( null() ) {} + ~KRange() {} + + public: + KRange &operator=( const KRange &R ) { Start = R.Start; End = R.End; return *this; } + + public: + bool operator==( const KRange &R ) const { return Start == R.Start && End == R.End; } + + public: // modification access + /** sets the first and the last index of the range */ + void set( T S, T E ) { Start = S; End = E; } + /** sets the first index of the range */ + void setStart( T S ) { Start = S; } + /** sets the last index of the range */ + void setEnd( T E ) { End = E; } + /** sets the range to null */ + void unset() { Start = End = null(); } + /** restricts the range to Limit. If one of both ranges is invalid the behaviour is undefined */ + void restrictTo( const KRange &Limit ) + { if( Start < Limit.start() ) Start = Limit.start(); if( End > Limit.end() ) End = Limit.end(); } + /** restricts the start to Limit. If the range is invalid the behaviour is undefined */ + void restrictStartTo( T Limit ) { if( Start < Limit ) Start = Limit; } + /** restricts the end to Limit. If the range is invalid the behaviour is undefined */ + void restrictEndTo( T Limit ) { if( End > Limit ) End = Limit; } + /** extends the range to Limit. If one of both is invalid the behaviour is undefined */ + void extendTo( const KRange &Limit ) + { if( Start > Limit.start() ) Start = Limit.start(); if( End < Limit.end() ) End = Limit.end(); } + /** extends the start to Limit. If the range is invalid the behaviour is undefined */ + void extendStartTo( T Limit ) { if( Start > Limit ) Start = Limit; } + /** extends the end to Limit. If the range is invalid the behaviour is undefined */ + void extendEndTo( T Limit ) { if( End < Limit ) End = Limit; } + /** moves the range by D. If the range is invalid the behaviour is undefined */ + void moveBy( T D ) { Start += D; End += D; } + + public: // value access + /** @return start */ + T start() const { return Start; } + /** @return end */ + T end() const { return End; } + + + public: // logic access + /** returns true if Value is covered */ + bool includes( T Value ) const { return Value <= End && Value >= Start; } + /** returns true if range is before index. if range is invalid the behaviour is undefined */ + bool endsBefore( T Value ) const { return End < Value; } + /** returns true if range is behind index. if range is invalid the behaviour is undefined */ + bool startsBehind( T Value ) const { return Start > Value; } + /** returns true is the range starts before index. If the range is invalid the behaviour is undefined */ + bool startsBefore( T Value ) const { return Start < Value; } + /** returns true is the range end later then index. If the range is invalid the behaviour is undefined */ + bool endsBehind( T Value ) const { return End > Value; } + + /** returns true is the range covers R. If one of both is invalid the behaviour is undefined */ + bool includes( const KRange &R ) const { return End >= R.End && Start <= R.Start; } + /** returns true is the range ends before R starts. If one of both is invalid the behaviour is undefined */ + bool endsBefore( const KRange &R ) const { return End < R.Start; } + /** returns true is the range starts later than R ends. If one of both is invalid the behaviour is undefined */ + bool startsBehind( const KRange &R ) const { return Start > R.End; } + /** returns true is the range starts prior than R. If one of both is invalid the behaviour is undefined */ + bool startsBefore( const KRange &R ) const { return Start < R.Start; } + /** returns true is the range ends later than R. If one of both is invalid the behaviour is undefined */ + bool endsBehind( const KRange &R ) const { return End > R.End; } + /** returns true is the range shares at least one index with R. If one of both is invalid the behaviour is undefined */ + bool overlaps( const KRange &R ) const { return Start <= R.End && End >= R.Start; } + + /** returns true if the range covers at least one index */ + bool isValid() const { return Start != null() && Start <= End; } + /** returns true if the range has not been set */ + bool isEmpty() const { return Start == null() && End == null(); } + + + protected: + /** delivers a null element. Should be specialiced for complexer types. */ + const T null () const { return T(-1);} + + protected: + /** first value of the range */ + T Start; + /** last value of the range */ + T End; +}; + +} + +#endif diff --git a/khexedit/lib/kreadonlybuffer.h b/khexedit/lib/kreadonlybuffer.h new file mode 100644 index 0000000..63264b2 --- /dev/null +++ b/khexedit/lib/kreadonlybuffer.h @@ -0,0 +1,45 @@ +/*************************************************************************** + kreadonlybuffer.h - description + ------------------- + begin : Mit Mai 14 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KREADONLYBUFFER_H +#define KHE_KREADONLYBUFFER_H + +#include "kdatabuffer.h" + +namespace KHE +{ + +/** + *@author Friedrich W. H. Kossebau + */ + +class KReadOnlyBuffer : public KDataBuffer +{ + public: + KReadOnlyBuffer() {} + ~KReadOnlyBuffer() {} + + public: // KDataBuffer API + /** is the buffer changeable ?*/ + virtual bool isReadOnly() const { return true; } + /** has the buffer been modified? */ + virtual bool isModified() const { return false; } +}; + +} + +#endif diff --git a/khexedit/lib/ksection.h b/khexedit/lib/ksection.h new file mode 100644 index 0000000..7693219 --- /dev/null +++ b/khexedit/lib/ksection.h @@ -0,0 +1,108 @@ +/*************************************************************************** + ksection.h - description + ------------------- + begin : Sun 22.06.2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de +****************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KSECTION_H +#define KHE_KSECTION_H + + +#include "krange.h" + +namespace KHE +{ + +/** describes a section of indizes + *@author Friedrich W. H. Kossebau + */ +class KSection : public KRange<int> +{ + public: + /** constructs a section + * @param SI starting index + * @param EI end index + */ + KSection( int SI, int EI ); + /** constructs a section + * @param SI starting index + * @param W width of the section + */ + KSection( int SI, int W, bool ); + KSection(); + ~KSection(); + + public: + KSection &operator=( const KSection &S ); + + public: + bool operator==( const KSection &S ) const; + + public: + void setByWidth( int S, int Width ); + /** sets the first index of the section's range one behind the other's end + * If one of both is invalid the behaviour is undefined + */ + void setStartBehind( KSection S ); + /** sets the first index of the section's range one behind the other's end + * If one of both is invalid or the other' start is 0 the behaviour is undefined + */ + void setEndBefore( KSection S ); + /** sets the first index of the section's range to be width-1 before the end + * If the section is invalid the behaviour is undefined + */ + void setStartByWidth( int Width ); + /** sets the last index of the section's range to be width-1 behind the start + * If the section is invalid the behaviour is undefined + */ + void setEndByWidth( int Width ); + /** moves the range defined by a new start. + * If the range is invalid the behaviour is undefined + */ + void moveToStart( int S ); + /** moves the range defined by a new start. + * If the range is invalid the behaviour is undefined + */ + void moveToEnd( int E ); + + public: + /** + * @return the numbered of included indizes or 0, if the section is invalid + */ + int width() const; +}; + + +inline KSection::KSection( int SI, int EI ) : KRange<int>(SI,EI) {} +inline KSection::KSection( int SI, int W, bool ) : KRange<int>(SI,SI+W-1) {} +inline KSection::KSection() {} +inline KSection::~KSection() {} + +inline bool KSection::operator==( const KSection &S ) const { return KRange<int>::operator==(S); } + +inline KSection &KSection::operator=( const KSection &S ) { KRange<int>::operator=(S); return *this; } + +inline int KSection::width() const { return isValid() ? end()-start()+1 : 0; } + +inline void KSection::setByWidth( int S, int Width ) { setStart( S ); setEnd( S+Width-1 ); } +inline void KSection::setStartByWidth( int Width ) { setStart( end()-Width+1 ); } +inline void KSection::setEndByWidth( int Width ) { setEnd( start()+Width-1 ); } +inline void KSection::setStartBehind( KSection S ) { setStart( S.end()+1 ); } +inline void KSection::setEndBefore( KSection S ) { setEnd( S.start()-1 ); } + +inline void KSection::moveToStart( int S ) { setEnd( S+width()-1 ); setStart( S ); } +inline void KSection::moveToEnd( int E ) { setStart( E-width()+1 ); setEnd( E ); } +} + +#endif diff --git a/khexedit/lib/ksectionlist.cpp b/khexedit/lib/ksectionlist.cpp new file mode 100644 index 0000000..eec54e4 --- /dev/null +++ b/khexedit/lib/ksectionlist.cpp @@ -0,0 +1,79 @@ +/*************************************************************************** + ksectionlist.cpp - description + ------------------- + begin : Mon Jun 30 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "ksectionlist.h" + +using namespace KHE; + +KSectionList::KSectionList() +{ +} + + +KSectionList::~KSectionList() +{ +} + + +void KSectionList::addSection( KSection NewSection ) +{ + if( !NewSection.isValid() ) + return; + + // we try to insert it by ascending indizes + // if sections are overlapping we combine them + iterator S = begin(); + for( ; S!=end(); ++S ) + { + // is new section before the next section? + if( NewSection.endsBefore(*S) ) + { + // put the new before it + insert( S, NewSection ); + return; + } + + // does the next section overlap? + if( (*S).overlaps(NewSection) ) + { + // Start of the combined sections is the smaller one + NewSection.extendStartTo( (*S).start() ); + // next we search all the overlapping sections and keep the highest end index + int End = (*S).end(); + iterator LS = S; + for( ++LS; LS!=end(); ++LS ) + { + if( !(*LS).overlaps(NewSection) ) + break; + End = (*LS).end(); + } + // the higher end is the end of the combined section + NewSection.extendEndTo( End ); + // remove all overlapping sections + S = erase( S, LS ); + // and instead insert the combined one + insert( S, NewSection ); + return; + } + } + + // all others are before the new? + if( S == end() ) + // add it at the end + append( NewSection ); +} diff --git a/khexedit/lib/ksectionlist.h b/khexedit/lib/ksectionlist.h new file mode 100644 index 0000000..7328e42 --- /dev/null +++ b/khexedit/lib/ksectionlist.h @@ -0,0 +1,44 @@ +/*************************************************************************** + ksectionlist.h - description + ------------------- + begin : Mon Jun 30 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KSECTIONLIST_H +#define KHE_KSECTIONLIST_H + +// qt specific +#include <qvaluelist.h> +// lib specific +#include "ksection.h" + +namespace KHE { + +typedef QValueList<KSection> KSectionBasicList; +/** +@author Friedrich W. H. Kossebau +*/ +class KSectionList : public KSectionBasicList +{ + public: + KSectionList(); + ~KSectionList(); + + public: + void addSection( KSection S ); +}; + +} + +#endif diff --git a/khexedit/lib/kselection.h b/khexedit/lib/kselection.h new file mode 100644 index 0000000..19b8a99 --- /dev/null +++ b/khexedit/lib/kselection.h @@ -0,0 +1,178 @@ +/*************************************************************************** + kbuffersection.h - description + ------------------- + begin : 22.06.2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de +****************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KSELECTION_H +#define KHE_KSELECTION_H + +#include "ksection.h" + +namespace KHE +{ + +/** This class describes a selected section of the buffer. + * As it is used as selection controlled by + * mouse and keyboard commands it offers two ways to set its range: + * - by giving the startposition (of the cursor) of an interactive selection + * and the subsequent end positions (until selection is finished) + * - direct setting (as provided by KSection) + * + * the interactive selection takes care that + * + *@author Friedrich W. H. Kossebau + */ +class KSelection : public KSection +{ + public: + /** creates a selection with a given start. + * @param Index index in front of which the selection begins + */ + KSelection( int Index ); + /** creates an invalid selection */ + KSelection(); + ~KSelection(); + + public: + KSelection &operator=( const KSelection &S ); + KSelection &operator=( const KSection &S ); + + public: // modification access + /** starts the selection. + * For this the anchor, start and end are set to the given index, + * so the initial selection is empty. + * @param Index index in front of which the selection begins + */ + void setStart( int Index ); + /** sets the end of the current selection + * If the end is before the start the selection will reach from the given index + * @param Index index in front of which the selection ends + */ + void setEnd( int Index ); + /** sets the selection to be invalid + */ + void cancel(); + /** sets the anchor to the start + * If the selection has not started the behaviour is undefined. + */ + void setForward(); + /** sets the anchor to the end + * If the selection has not started the behaviour is undefined. + */ + void setBackward(); + /** swaps anchor from start to end or vice versa + * If the selection has not started the behaviour is undefined. + */ + void reverse(); + + public: // value access + /** + * @return anchor value + */ + int anchor() const; + + public: // logic access + /** + * @return @c true if the anchor has been set, otherwise @c false. + */ + bool started() const; + /** + * @return @c true if the anchor has been set and the selection is empty, otherwise @c false. + */ + bool justStarted() const; + /** + * @return @c true if the anchor is at the begin of the selection + */ + bool isForward() const; + + protected: + /** cursor index where the selection starts */ + int Anchor; +}; + + +inline KSelection::KSelection() : Anchor( -1 ) {} +inline KSelection::KSelection( int Index ) : Anchor( Index ) {} +inline KSelection::~KSelection() {} + +inline KSelection &KSelection::operator=( const KSelection &S ) +{ + KSection::operator=(S); + Anchor = S.Anchor; + return *this; +} + +inline KSelection &KSelection::operator=( const KSection &S ) +{ + KSection::operator=(S); + Anchor = start(); + return *this; +} + + +inline void KSelection::setStart( int Index ) +{ + Anchor = Index; + unset(); +} + + +inline void KSelection::setEnd( int Index ) +{ + // nothing selected? + if( Index == Anchor ) + unset(); + // selecting forwards? + else if( Index > Anchor ) + { + KSection::setStart( Anchor ); + KSection::setEnd( Index-1 ); + } + // selecting backwards + else + { + KSection::setStart( Index ); + KSection::setEnd( Anchor-1 ); + } +} + +inline void KSelection::reverse() +{ + Anchor = isForward() ? end()+1 : start(); +} + +inline void KSelection::setForward() +{ + Anchor = start(); +} + +inline void KSelection::setBackward() +{ + Anchor = end()+1; +} + +inline int KSelection::anchor() const { return Anchor; } + +inline void KSelection::cancel() { Anchor = -1; unset(); } + +inline bool KSelection::started() const { return Anchor != -1; } + +inline bool KSelection::justStarted() const { return Anchor != -1 && start() == -1; } + +inline bool KSelection::isForward() const { return Anchor == start(); } + +} + +#endif diff --git a/khexedit/lib/kvaluecoltextexport.cpp b/khexedit/lib/kvaluecoltextexport.cpp new file mode 100644 index 0000000..009ad54 --- /dev/null +++ b/khexedit/lib/kvaluecoltextexport.cpp @@ -0,0 +1,69 @@ +/*************************************************************************** + kvaluecoltextexport.cpp - description + ------------------- + begin : Wed Sep 3 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "kbufferlayout.h" +#include "kvaluecolumn.h" +#include "kvaluecoltextexport.h" +#include "helper.h" + + +using namespace KHE; + +KValueColTextExport::KValueColTextExport( const KValueColumn* HC, const char *D, KCoordRange CR ) + : KBufferColTextExport( HC, D, CR, HC->byteCodec()->encodingWidth() ), + ByteCodec( KByteCodec::createCodec(HC->coding()) ) +{ +} + + +KValueColTextExport::~KValueColTextExport() +{ + delete ByteCodec; +} + + + +void KValueColTextExport::print( QString &T ) const +{ + int p = 0; + int pEnd = NoOfBytesPerLine; + // correct boundaries + if( PrintLine == CoordRange.start().line() ) + p = CoordRange.start().pos(); + if( PrintLine == CoordRange.end().line() ) + pEnd = CoordRange.end().pos()+1; + + QString E; + E.setLength( ByteCodec->encodingWidth() ); + // draw individual chars + uint e = 0; + for( ; p<pEnd; ++p, ++PrintData ) + { + // get next position + uint t = Pos[p]; + // clear spacing + T.append( whiteSpace(t-e) ); + ByteCodec->encode( E, 0, *PrintData ); + T.append( E ); + e = t + ByteCodec->encodingWidth(); + } + + T.append( whiteSpace(NoOfCharsPerLine-e) ); + ++PrintLine; +} + diff --git a/khexedit/lib/kvaluecoltextexport.h b/khexedit/lib/kvaluecoltextexport.h new file mode 100644 index 0000000..be6bab4 --- /dev/null +++ b/khexedit/lib/kvaluecoltextexport.h @@ -0,0 +1,47 @@ +/*************************************************************************** + kvaluecoltextexport.h - description + ------------------- + begin : Sam Aug 30 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KVALUECOLTEXTEXPORT_H +#define KHE_KVALUECOLTEXTEXPORT_H + +#include "kbytecodec.h" +#include "kbuffercoltextexport.h" + + +namespace KHE +{ + +class KValueColumn; + + +class KValueColTextExport : public KBufferColTextExport +{ + public: + KValueColTextExport( const KValueColumn* BF, const char *D, KCoordRange CR ); + virtual ~KValueColTextExport(); + + protected: + virtual void print( QString &T ) const; + + + protected: + KByteCodec *ByteCodec; +}; + +} + +#endif diff --git a/khexedit/lib/kvaluecolumn.cpp b/khexedit/lib/kvaluecolumn.cpp new file mode 100644 index 0000000..82da795 --- /dev/null +++ b/khexedit/lib/kvaluecolumn.cpp @@ -0,0 +1,134 @@ +/*************************************************************************** + kvaluecolumn.cpp - description + ------------------- + begin : Mit Sep 3 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// qt specific +#include <qpainter.h> +// lib specific +#include "kcolumnsview.h" +#include "kbuffercursor.h" +#include "kbufferlayout.h" +#include "kbufferranges.h" +#include "kvaluecolumn.h" +#include "helper.h" +#include "kcharcodec.h" + +using namespace KHE; + +static const KCoding DefaultCoding = HexadecimalCoding; +static const KCoding NotDefaultCoding = DecimalCoding; +static const int DefaultBinaryGapWidth = 1; + + +KValueColumn::KValueColumn( KColumnsView *CV, KDataBuffer *B, KBufferLayout *L, KBufferRanges *R ) + : KBufferColumn( CV, B, L, R ), + Coding( NotDefaultCoding ), + ByteCodec( 0 ), + BinaryGapWidth( DefaultBinaryGapWidth ) +{ + setCoding( DefaultCoding ); +} + + +KValueColumn::~KValueColumn() +{ +} + + + +bool KValueColumn::setCoding( KCoding C ) +{ + // no changes? + if( Coding == C ) + return false; + + delete ByteCodec; + + Coding = C; + ByteCodec = KByteCodec::createCodec( Coding ); + CodedByte.setLength( ByteCodec->encodingWidth() ); + + // recalculate depend sizes + recalcByteWidth(); + + if( PosX ) + recalcX(); + return true; +} + + +bool KValueColumn::setBinaryGapWidth( KPixelX BGW ) +{ + // no changes? + if( BinaryGapWidth == BGW ) + return false; + + BinaryGapWidth = BGW; + + // recalculate depend sizes + recalcByteWidth(); + + if( PosX ) + recalcX(); + return true; +} + + +void KValueColumn::recalcByteWidth() +{ + ByteWidth = ByteCodec->encodingWidth() * DigitWidth; + + if( Coding == BinaryCoding ) + { + BinaryHalfOffset = 4 * DigitWidth + BinaryGapWidth; + ByteWidth += BinaryGapWidth; + } + recalcVerticalGridX(); +} + + +// perhaps sometimes there will be a grammar +void KValueColumn::paintEditedByte( QPainter *P, char Byte, const QString &EditBuffer ) +{ + KHEChar B = Codec->decode( Byte ); + + const QColorGroup &CG = View->colorGroup(); + + P->fillRect( 0,0,ByteWidth,LineHeight, QBrush(colorForChar(B),Qt::SolidPattern) ); + + drawCode( P, EditBuffer, CG.base() ); +} + + +void KValueColumn::drawByte( QPainter *P, char Byte, KHEChar /*B*/, const QColor &Color ) const +{ + ByteCodec->encode( CodedByte, 0, Byte ); + drawCode( P, CodedByte, Color ); +} + + +void KValueColumn::drawCode( QPainter *P, const QString &Code, const QColor &Color ) const +{ + P->setPen( Color ); + if( Coding == BinaryCoding ) + { + // leave a gap in the middle + P->drawText( 0, DigitBaseLine, Code.left(4) ); + P->drawText( BinaryHalfOffset, DigitBaseLine, Code.right(4) ); + } + else + P->drawText( 0, DigitBaseLine, Code ); +} diff --git a/khexedit/lib/kvaluecolumn.h b/khexedit/lib/kvaluecolumn.h new file mode 100644 index 0000000..cc25929 --- /dev/null +++ b/khexedit/lib/kvaluecolumn.h @@ -0,0 +1,92 @@ +/*************************************************************************** + kvaluecolumn.h - description + ------------------- + begin : Mit Sep 3 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KVALUECOLUMN_H +#define KHE_KVALUECOLUMN_H + +// lib specific +#include "kbytecodec.h" +#include "kbuffercolumn.h" + + +namespace KHE +{ + +class KBufferRanges; + + +/** buffer column which displays the numerical values of the bytes + * + *@author Friedrich W. H. Kossebau + */ +class KValueColumn : public KBufferColumn +{ + public: + KValueColumn( KColumnsView *CV, KDataBuffer *B, KBufferLayout *L, KBufferRanges *R ); + virtual ~KValueColumn(); + + public: + void paintEditedByte( QPainter *P, char Byte, const QString &EditBuffer ); + + public: // modification access + /** + * returns true if there was a change + */ + bool setCoding( KCoding C ); + /** sets the spacing in the middle of a binary byte in the value column + * @param BinaryGapW spacing in the middle of a binary in pixels + * returns true if there was a change + */ + bool setBinaryGapWidth( KPixelX BGW ); + + + public: // value access + KPixelX binaryGapWidth() const; + KCoding coding() const; + const KByteCodec *byteCodec() const; + + + protected: // KBufferColumn API + virtual void drawByte( QPainter *P, char Byte, KHEChar B, const QColor &Color ) const; + virtual void recalcByteWidth(); + + protected: + void drawCode( QPainter *P, const QString &Code, const QColor &Color ) const; + + protected: // set data + /** */ + KCoding Coding; + /** */ + KByteCodec *ByteCodec; + /** */ + KPixelX BinaryGapWidth; + + protected: // buffered data + /** buffer to hold the formatted coding */ + mutable QString CodedByte; + /** calculated: Offset in pixels of the second half of the binary */ + KPixelX BinaryHalfOffset; +}; + + +inline KPixelX KValueColumn::binaryGapWidth() const { return BinaryGapWidth; } +inline KCoding KValueColumn::coding() const { return Coding; } +inline const KByteCodec *KValueColumn::byteCodec() const { return ByteCodec; } + +} + +#endif diff --git a/khexedit/lib/kwordbufferservice.cpp b/khexedit/lib/kwordbufferservice.cpp new file mode 100644 index 0000000..0489139 --- /dev/null +++ b/khexedit/lib/kwordbufferservice.cpp @@ -0,0 +1,209 @@ +/*************************************************************************** + kwordbufferservice.cpp - description + ------------------- + begin : Di Jan 18 2005 + copyright : (C) 2005 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +// lib specific +#include "kdatabuffer.h" +#include "kcharcodec.h" +#include "kwordbufferservice.h" + +using namespace KHE; + + +bool KWordBufferService::isWordChar( unsigned int Index ) const +{ + KHEChar C = CharCodec->decode( Buffer->datum(Index) ); + return !C.isUndefined() && C.isLetterOrNumber(); +} + + +int KWordBufferService::indexOfPreviousWordStart( unsigned int Index ) const +{ + unsigned int Size = Buffer->size(); + // already at the start or can the result only be 0? + if( Index == 0 || Size < 3 ) + return 0; + + // search in two rounds: first for the next char, than for the next nonchar + // after that return the index of the one before + bool LookingForFirstWordChar = false; + for( ; Index>0; --Index ) + { + if( !isWordChar(Index-1) ) + { + if( !LookingForFirstWordChar ) + continue; + return( Index ); + } + else if( !LookingForFirstWordChar ) + LookingForFirstWordChar = true; + } + return 0; +} + + +int KWordBufferService::indexOfNextWordStart( unsigned int Index ) const +{ + unsigned int Size = Buffer->size(); + bool LookingForFirstWordChar = false; + for( ; Index<Size; ++Index ) + { + if( isWordChar(Index) ) + { + if( !LookingForFirstWordChar ) + continue; + return Index; + } + else if( !LookingForFirstWordChar ) + LookingForFirstWordChar = true; + } + // if no more word found, go to the end + return Size; +} + + +int KWordBufferService::indexOfBeforeNextWordStart( unsigned int Index ) const +{ + unsigned int Size = Buffer->size(); + bool LookingForFirstWordChar = false; + for( ; Index<Size; ++Index ) + { + if( isWordChar(Index) ) + { + if( !LookingForFirstWordChar ) + continue; + return Index-1; + } + else if( !LookingForFirstWordChar ) + LookingForFirstWordChar = true; + } + // if no more word found, go to the end + return Size-1; +} + + +int KWordBufferService::indexOfWordStart( unsigned int Index ) const +{ + for( ; Index > 0; --Index ) + { + if( !isWordChar(Index-1) ) + return( Index ); + } + return 0; +} + + +int KWordBufferService::indexOfWordEnd( unsigned int Index ) const +{ + unsigned int Size = Buffer->size(); + for( ++Index; Index<Size; ++Index ) + { + if( !isWordChar(Index) ) + return Index-1; + } + // word reaches the end + return Size-1; +} + + +int KWordBufferService::indexOfLeftWordSelect( unsigned int Index ) const +{ + // word at Index? + if( isWordChar(Index) ) + { + // search for word start to the left + for( ; Index>0; --Index ) + { + if( !isWordChar(Index-1) ) + return Index; + } + // reached start, so return it + return 0; + } + else + { + unsigned int Size = Buffer->size(); + // search for word start to the right + for( ++Index; Index<Size; ++Index ) + { + if( isWordChar(Index) ) + return Index; + } + // word reaches the end, so step behind + return Size; + } +} + + +int KWordBufferService::indexOfRightWordSelect( unsigned int Index ) const +{ + // no word at Index? + if( !isWordChar(Index) ) + { + // search for word end to the left + for( ; Index>0; --Index ) + { + if( isWordChar(Index-1) ) + return Index; + } + // reached start, so return it + return 0; + } + else + { + unsigned int Size = Buffer->size(); + for( ++Index; Index<Size; ++Index ) + { + // search for word end to the right + if( !isWordChar(Index) ) + return Index; + } + // word reaches the end, so step behind + return Size; + } +} + +/* +int KWordBufferService::indexOfBehindWordEnd( unsigned int Index ) const +{ + // no word at Index? + return !::isWordChar(datum(Index)) ? indexOfBehindLeftWordEnd(Index) : indexOfBehindRightWordEnd(Index+1) +} + + +int KWordBufferService::indexOfBehindRightWordEnd( unsigned int Index ) const +{ + for( ; Index<size(); ++Index ) +{ + if( !::isWordChar(datum(Index)) ) + return Index; +} + // word reaches the end, so step behind + return size(); +} + + +int KWordBufferService::indexOfBehindLeftWordEnd( unsigned int Index ) const +{ + for( --Index; Index>=0; --Index ) +{ + if( ::isWordChar(datum(Index)) ) + return Index+1; +} + // word reaches the end, so step behind + return 0; +} +*/ diff --git a/khexedit/lib/kwordbufferservice.h b/khexedit/lib/kwordbufferservice.h new file mode 100644 index 0000000..805f064 --- /dev/null +++ b/khexedit/lib/kwordbufferservice.h @@ -0,0 +1,137 @@ +/*************************************************************************** + kwordbufferservice.h - description + ------------------- + begin : Di Jan 18 2005 + copyright : (C) 2005 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KWORDBUFFERSERVICE_H +#define KHE_KWORDBUFFERSERVICE_H + +// lib specific +#include "ksection.h" + +namespace KHE +{ + +class KDataBuffer; +class KCharCodec; + +/** + * + *@author Friedrich W. H. Kossebau + */ + +class KWordBufferService +{ + public: + KWordBufferService( KDataBuffer *B, KCharCodec *C ); + ~KWordBufferService(); + + + public: + /** searches for the start of the word including the given index. + * if no other nonwordchar preceds this is 0; + * If the byte at the given Index is already a nonword char the given index is returned. + * @param Index index to start with + * @param CharType + * @return index of the first char of the current word or the given index if there is none + */ + int indexOfWordStart( unsigned int Index ) const; + int indexOfLeftWordSelect( unsigned int Index ) const; + /** searches for the end of the word including the given index. + * If the byte at the given Index is already a nonword char the given index is returned. + * if no other nonwordchar follows, that of the last byte; + * @param Index index to start with + * @param CharType + * @return index of the last char of the current word or the given index if there is none + */ + int indexOfWordEnd( unsigned int Index ) const; + /** searches for the first char after the end of the word including the given index. + * If the byte at the given Index is already a nonword char the given index is returned. + * if no other nonwordchar follows that of behind the last byte; + * @param Index index to start with + * @param CharType + * @return index of the first char after the current word or the given index if there is none + */ + int indexOfRightWordSelect( unsigned int Index ) const; + /** searches for the first char after the end of the word including the given index. + * If the byte at the given Index is already a nonword char the given index is returned. + * if no other nonwordchar follows that of behind the last byte; + * @param Index index to start with + * @param CharType + * @return index of the first char after the current word or the given index if there is none + */ +// int indexOfBehindLeftWordEnd( unsigned int Index ) const; + /** searches for the first char after the end of the word including the given index. + * If the byte at the given Index is already a nonword char the given index is returned. + * if no other nonwordchar follows that of behind the last byte; + * @param Index index to start with + * @param CharType + * @return index of the first char after the current word or the given index if there is none + */ +// int indexOfBehindRightWordEnd( unsigned int Index ) const; + /** searches the start of the next previous word that does not include the given index, + * if no further word is found 0 is returned. + * if the index is out of range the behaviour is undefined. + * @param Index + * @param CharType + * @return index of the next previous word start or 0 + */ + int indexOfPreviousWordStart( unsigned int Index ) const; + /** searches for the start of the next word not including the given index. + * if there isn't a next word the index behind end is returned + * @param Index + * @param CharType + * @return index of the start of the next word or behind end + */ + int indexOfNextWordStart( unsigned int Index ) const; + /** searches for the start of the next word not including the given index. + * if there isn't a next word the index of the end is returned + * @param Index index to start with + * @param CharType + * @return index of the last nonword char before the next word or the last index + */ + int indexOfBeforeNextWordStart( unsigned int Index ) const; + + /** if Index is out of range the behaviour is undefined + * @param Index + * @param CharType + * @return @c true if the byte at position i is a char of type CharType + */ + bool isWordChar( unsigned int Index ) const; + + /** returns the section with a word around index. + * if there is no word the section is empty + * @param Index + * @param CharType + * @return the section with a word around index. + */ + KSection wordSection( unsigned int Index ) const; + + protected: + KDataBuffer *Buffer; + KCharCodec *CharCodec; +}; + + +inline KWordBufferService::KWordBufferService( KDataBuffer *B, KCharCodec *C ) + : Buffer( B ), CharCodec( C ) {} +inline KWordBufferService::~KWordBufferService() {} + +inline KSection KWordBufferService::wordSection( unsigned int Index ) const +{ return isWordChar(Index) ? KSection( indexOfWordStart(Index), indexOfWordEnd(Index) ) : KSection(); } + +} + +#endif diff --git a/khexedit/lib/kwrappingrobuffer.cpp b/khexedit/lib/kwrappingrobuffer.cpp new file mode 100644 index 0000000..b913c1a --- /dev/null +++ b/khexedit/lib/kwrappingrobuffer.cpp @@ -0,0 +1,61 @@ +/*************************************************************************** + kwrappingrobuffer.cpp - description + ------------------- + begin : Mit Mai 14 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#include "kwrappingrobuffer.h" + +using namespace KHE; + +KWrappingROBuffer::KWrappingROBuffer( const char* D, int L ) +{ + Data = D; + Size = L; +} + +KWrappingROBuffer::KWrappingROBuffer() +{ + Data = 0L; + Size = 0; +} + + +KWrappingROBuffer::~KWrappingROBuffer() +{ +} + + +const char *KWrappingROBuffer::dataSet( KSection S ) const +{ + return &Data[S.start()]; +} + + +void KWrappingROBuffer::set( const char* D, int L ) +{ + Data = D; + Size = L; +} + + +int KWrappingROBuffer::find( const char*/*KeyData*/, int /*Length*/, KSection /*Section*/ ) const +{ + return 0; +} + +int KWrappingROBuffer::rfind( const char*, int /*Length*/, int /*Pos*/ ) const +{ + return 0; +} diff --git a/khexedit/lib/kwrappingrobuffer.h b/khexedit/lib/kwrappingrobuffer.h new file mode 100644 index 0000000..51ee7b8 --- /dev/null +++ b/khexedit/lib/kwrappingrobuffer.h @@ -0,0 +1,85 @@ +/*************************************************************************** + kwrappingrobuffer.h - description + ------------------- + begin : Mit Mai 14 2003 + copyright : (C) 2003 by Friedrich W. H. Kossebau + email : Friedrich.W.H@Kossebau.de + ***************************************************************************/ + +/*************************************************************************** + * * + * This library is free software; you can redistribute it and/or * + * modify it under the terms of the GNU Library General Public * + * License version 2 as published by the Free Software Foundation. * + * * + ***************************************************************************/ + + +#ifndef KHE_KWRAPPINGROBUFFER_H +#define KHE_KWRAPPINGROBUFFER_H + +#include "kreadonlybuffer.h" + +namespace KHE +{ + +/** + *@author Friedrich W. H. Kossebau + */ + +class KWrappingROBuffer : public KReadOnlyBuffer +{ + public: + static const int NothingFound = -1; + + public: + KWrappingROBuffer(); + KWrappingROBuffer( const char* D, int L ); + virtual ~KWrappingROBuffer(); + + + public: // KDataBuffer API + virtual bool prepareRange( KSection Range ) const; + virtual const char *dataSet( KSection S ) const; + virtual char datum( unsigned int Offset ) const; + virtual int size() const; + virtual bool isModified() const; + + virtual int insert( int Pos, const char*, int Length ); + virtual int remove( KSection S ); + virtual unsigned int replace( KSection S, const char*, unsigned int Length ); + virtual int fill( const char FillChar, int, int ); + virtual void setDatum( unsigned int Offset, const char Char ); + + virtual void setModified( bool M ); + + virtual int find( const char*KeyData, int Length, KSection Section ) const; + virtual int rfind( const char*, int Length, int Pos = -1 ) const; + + + public: // + void set( const char* D, int L ); + + protected: + const char* Data; + int Size; + bool Modified; +}; + +inline int KWrappingROBuffer::size() const { return Size; } + +inline bool KWrappingROBuffer::isModified() const { return Modified; } + +inline bool KWrappingROBuffer::prepareRange( KSection ) const { return true; } +inline char KWrappingROBuffer::datum( unsigned int Offset ) const { return Data[Offset]; } + +inline int KWrappingROBuffer::insert( int, const char*, int ) { return 0; } +inline int KWrappingROBuffer::remove( KSection ) { return 0; } +inline unsigned int KWrappingROBuffer::replace( KSection, const char*, unsigned int ) { return 0; } +inline int KWrappingROBuffer::fill( const char , int, int ) { return 0; } +inline void KWrappingROBuffer::setDatum( unsigned int, const char ) {} + +inline void KWrappingROBuffer::setModified( bool M ) { Modified = M; } +} + +#endif |