HeeroYui/edn
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Compare commits

base: HeeroYui:dev-testDisplayLineByLine
Branches Tags
HeeroYui:master HeeroYui:dev HeeroYui:1.0 HeeroYui:gh-pages HeeroYui:dev-testDisplayLineByLine
HeeroYui:1.3.0 HeeroYui:1.2.4 HeeroYui:1.2.3 HeeroYui:1.2.2 HeeroYui:1.2.1 HeeroYui:1.2.0 HeeroYui:1.1.2 HeeroYui:1.1.1 HeeroYui:1.1.0 HeeroYui:0.4.0 HeeroYui:0.3.9 HeeroYui:0.3.8 HeeroYui:0.3.7 HeeroYui:0.3.6 HeeroYui:0.3.5 HeeroYui:0.3.4 HeeroYui:0.3.3 HeeroYui:0.3.2 HeeroYui:0.3.1 HeeroYui:0.3.0 HeeroYui:0.2.3 HeeroYui:0.2.2 HeeroYui:0.2.1 HeeroYui:0.2.0 HeeroYui:0.1.7 HeeroYui:0.1.6 HeeroYui:0.1.5 HeeroYui:0.1.4 HeeroYui:0.1.3 HeeroYui:0.1.2 HeeroYui:0.1.1
..
compare: HeeroYui:0.2.3
Branches Tags
HeeroYui:dev HeeroYui:master HeeroYui:1.0 HeeroYui:gh-pages HeeroYui:dev-testDisplayLineByLine
HeeroYui:1.3.0 HeeroYui:1.2.4 HeeroYui:1.2.3 HeeroYui:1.2.2 HeeroYui:1.2.1 HeeroYui:1.2.0 HeeroYui:1.1.2 HeeroYui:1.1.1 HeeroYui:1.1.0 HeeroYui:0.4.0 HeeroYui:0.3.9 HeeroYui:0.3.8 HeeroYui:0.3.7 HeeroYui:0.3.6 HeeroYui:0.3.5 HeeroYui:0.3.4 HeeroYui:0.3.3 HeeroYui:0.3.2 HeeroYui:0.3.1 HeeroYui:0.3.0 HeeroYui:0.2.3 HeeroYui:0.2.2 HeeroYui:0.2.1 HeeroYui:0.2.0 HeeroYui:0.1.7 HeeroYui:0.1.6 HeeroYui:0.1.5 HeeroYui:0.1.4 HeeroYui:0.1.3 HeeroYui:0.1.2 HeeroYui:0.1.1

1 Commits
dev-testDi ... 0.2.3

Author SHA1 Message Date
Edouard Dupin
863fab113b add patch correction done in branch display line by line 
stop the developpement of the display line by line because it did not work corectly and was a little cpu leacher, the display has maany error and the comphehention is hard.
 2011-10-11 14:06:36 +02:00
19 changed files with 511 additions and 1402 deletions
Expand all files Collapse all files

284
Sources/Buffer/Buffer.cpp
View File

@@ -41,8 +41,6 @@
*/
Buffer::Buffer()
{
static int32_t bufID = 0;
m_uniqueID = bufID++;
static int32_t fileBasicID = 0;
m_fileModify = true;
m_haveName = false;
@@ -50,23 +48,6 @@ Buffer::Buffer()
mString += fileBasicID++;
SetFileName(mString);
m_haveName = false;
// Set basic anchor
bufferAnchorReference_ts tmpAnchor;
tmpAnchor.m_displaySize.x = 0;
tmpAnchor.m_displaySize.y = 0;
tmpAnchor.m_displayStart.x = 0;
tmpAnchor.m_curent = true;
tmpAnchor.m_idAnchor = -1;
tmpAnchor.m_lineId = 0;
tmpAnchor.m_bufferPos = 0;
for(int32_t iii=0; iii<MAX_LINE_DISPLAYABLE_BY_BUFFER; iii++) {
tmpAnchor.m_redrawLine[iii] = true;
}
tmpAnchor.m_BufferNumberLineOffset = 0;
m_AnchorList.PushBack(tmpAnchor);
m_lineWidth = 10;
m_lineHeight = 10;
}
/**
@@ -81,20 +62,6 @@ Buffer::Buffer(Edn::File &newName)
{
m_fileModify = false;
SetFileName(newName);
// Set basic anchor
bufferAnchorReference_ts tmpAnchor;
tmpAnchor.m_displaySize.x = 0;
tmpAnchor.m_displaySize.y = 0;
tmpAnchor.m_displayStart.x = 0;
tmpAnchor.m_curent = true;
tmpAnchor.m_idAnchor = -1;
tmpAnchor.m_lineId = 0;
tmpAnchor.m_bufferPos = 0;
for(int32_t iii=0; iii<MAX_LINE_DISPLAYABLE_BY_BUFFER; iii++) {
tmpAnchor.m_redrawLine[iii] = true;
}
tmpAnchor.m_BufferNumberLineOffset = 0;
m_AnchorList .PushBack(tmpAnchor);
}
/**
@@ -179,29 +146,9 @@ void Buffer::SetLineDisplay(uint32_t lineNumber)
* @return ---
*
*/
void Buffer::DrawLine(DrawerManager &drawer, bufferAnchor_ts &anchor)
int32_t Buffer::Display(DrawerManager &drawer)
{
return;
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
void Buffer::DrawLineEmpty(DrawerManager &drawer, int32_t lineScreenID)
{
ColorizeManager * myColorManager = ColorizeManager::getInstance();
int32_t positionY = m_lineHeight * (lineScreenID);
# ifdef NDEBUG
drawer.Rectangle(myColorManager->Get(COLOR_CODE_BASIC_BG), 0, positionY, drawer.GetWidth(), m_lineHeight );
# else
drawer.Rectangle(myColorManager->Get(COLOR_CODE_CURSOR), 0, positionY, drawer.GetWidth(), m_lineHeight );
# endif
return ERR_NONE;
}
/**
@@ -288,6 +235,7 @@ void Buffer::ScrollUp(void)
// nothing to do
}
/**
* @brief
*
@@ -296,6 +244,13 @@ void Buffer::ScrollUp(void)
* @return ---
*
*/
void Buffer::ForceReDraw(bool allElement)
{
// nothing to do
}
void Buffer::cursorMove(int32_t gtkKey)
{
// nothing to do
@@ -393,7 +348,7 @@ void Buffer::Paste(int8_t clipboardID)
void Buffer::RemoveLine(void)
{
// nothing to do;
// nothing to do
}
void Buffer::SelectAll(void)
@@ -416,220 +371,3 @@ void Buffer::Redo(void)
// nothing to do
}
void Buffer::AnchorAdd(int32_t anchorID)
{
int32_t localID = AnchorRealId(anchorID);
if (localID >=0) {
EDN_ERROR("[" << m_uniqueID << "] AnchorID="<< anchorID << " already exist !!!");
} else {
bufferAnchorReference_ts tmpAnchor = m_AnchorList[0];
m_AnchorList[0].m_curent = false;
tmpAnchor.m_idAnchor = anchorID;
for(int32_t iii=0; iii<MAX_LINE_DISPLAYABLE_BY_BUFFER; iii++) {
tmpAnchor.m_redrawLine[iii] = true;
}
m_AnchorList.PushBack(tmpAnchor);
EDN_DEBUG("[" << m_uniqueID << "] AnchorID="<< anchorID << " ==> Added");
}
}
void Buffer::AnchorRm(int32_t anchorID)
{
if (anchorID == -1) {
EDN_ERROR("[" << m_uniqueID << "] AnchorID="<< anchorID << " Can not remove this one !!!");
return;
}
int32_t localID = AnchorRealId(anchorID);
if (localID >=0) {
if (m_AnchorList.Size() == 2) {
m_AnchorList[0] = m_AnchorList[1];
for(int32_t iii=0; iii<MAX_LINE_DISPLAYABLE_BY_BUFFER; iii++) {
m_AnchorList[0].m_redrawLine[iii] = true;
}
m_AnchorList[0].m_BufferNumberLineOffset = 0;
}
m_AnchorList.Erase(localID);
EDN_DEBUG("[" << m_uniqueID << "] AnchorID="<< anchorID << " ==> Remove");
} else {
EDN_ERROR("[" << m_uniqueID << "] AnchorID="<< anchorID << " does not exist !!!");
}
}
void Buffer::AnchorRedrawAll(int32_t anchorID)
{
if (anchorID == -1) {
EDN_ERROR("[" << m_uniqueID << "] AnchorID="<< anchorID << " Can not redraw this one !!!");
return;
}
int32_t localID = AnchorRealId(anchorID);
if (localID >=0) {
AnchorForceRedrawAll(localID);
} else {
EDN_ERROR("[" << m_uniqueID << "] AnchorID="<< anchorID << " does not exist !!!");
}
}
bool Buffer::AnchorGet(int32_t anchorID, bufferAnchor_ts & anchor)
{
EDN_ERROR("[" << m_uniqueID << "] AnchorID="<< anchorID << " Main buffer ==> can not manage Anchor (type buffer specific)");
return false;
}
bool Buffer::AnchorNext(bufferAnchor_ts & anchor)
{
EDN_ERROR("[" << m_uniqueID << "] AnchorID=?? Main buffer ==> can not manage Anchor (type buffer specific)");
return false;
}
void Buffer::AnchorSetSize(int32_t anchorID, int32_t sizePixelX, int32_t sizePixelY)
{
int32_t localID = AnchorRealId(anchorID);
if (localID >=0) {
position_ts mySize;
mySize.x = sizePixelX / m_lineWidth;
mySize.y = sizePixelY / m_lineHeight;
if( m_AnchorList[localID].m_displaySize.x != mySize.x
|| m_AnchorList[localID].m_displaySize.y != mySize.y )
{
AnchorForceRedrawAll(localID);
}
m_AnchorList[localID].m_displaySize = mySize;
}
}
void Buffer::AnchorSetStartOffset(int32_t anchorID, int32_t offsetX, int32_t offsetY)
{
int32_t localID = AnchorRealId(anchorID);
if (localID >=0) {
m_AnchorList[localID].m_displayStart.x += offsetX;
if (0<m_AnchorList[localID].m_displayStart.x) {
m_AnchorList[localID].m_displayStart.x = 0;
}
m_AnchorList[localID].m_displayStart.y += offsetY;
if (0<m_AnchorList[localID].m_displayStart.y) {
m_AnchorList[localID].m_displayStart.y = 0;
}
AnchorForceRedrawAll(localID);
}
}
int32_t Buffer::AnchorRealId(int32_t anchorID)
{
//EDN_DEBUG("Get real ID : " << anchorID << " in the anchor list size()=" << m_AnchorList.Size());
for(int32_t iii=0; iii < m_AnchorList.Size(); iii++) {
//EDN_DEBUG("check if equal : " << m_AnchorList[iii].m_idAnchor << " id=" << iii);
if (m_AnchorList[iii].m_idAnchor == anchorID) {
return iii;
}
}
return -1;
}
int32_t Buffer::AnchorCurrentId(void)
{
for(int32_t iii=0; iii < m_AnchorList.Size(); iii++) {
if (m_AnchorList[iii].m_curent == true) {
return iii;
}
}
return 0;
}
void Buffer::AnchorForceRedrawAll(int32_t realAnchorId)
{
EDN_DEBUG("AnchorForceRedrawAll(" << realAnchorId << ")");
if (-5000 == realAnchorId) {
int32_t localID = AnchorCurrentId();
if (localID >=0) {
m_AnchorList[localID].m_BufferNumberLineOffset = 0;
for(int32_t iii=0; iii < MAX_LINE_DISPLAYABLE_BY_BUFFER; iii++) {
m_AnchorList[localID].m_redrawLine[iii] = true;
}
}
} else {
m_AnchorList[realAnchorId].m_BufferNumberLineOffset = 0;
for(int32_t iii=0; iii < MAX_LINE_DISPLAYABLE_BY_BUFFER; iii++) {
m_AnchorList[realAnchorId].m_redrawLine[iii] = true;
}
}
}
void Buffer::AnchorForceRedrawLine(int32_t lineID)
{
for(int32_t iii=0; iii < m_AnchorList.Size(); iii++) {
if( m_AnchorList[iii].m_displayStart.y <= lineID
&& m_AnchorList[iii].m_displayStart.y + MAX_LINE_DISPLAYABLE_BY_BUFFER > lineID )
{
m_AnchorList[iii].m_redrawLine[lineID-m_AnchorList[iii].m_displayStart.y] = true;
}
}
}
// TODO : optimiser cette fonction qui met plusieurs fois des variables a true ....
void Buffer::AnchorForceRedrawOffsef(int32_t offset)
{
EDN_DEBUG("** => set ofset : " << offset);
if (0 == offset) {
EDN_DEBUG("No apply offset ...");
return;
}
int32_t localID = AnchorCurrentId();
if (localID >=0) {
EDN_DEBUG("offset ID=" << localID);
m_AnchorList[localID].m_BufferNumberLineOffset += offset;
EDN_DEBUG("move redraw request : [" << m_AnchorList[localID].m_displaySize.y << "," << MAX_LINE_DISPLAYABLE_BY_BUFFER << "[=true");
for(int32_t iii=m_AnchorList[localID].m_displaySize.y; iii < MAX_LINE_DISPLAYABLE_BY_BUFFER; iii++) {
m_AnchorList[localID].m_redrawLine[iii] = true;
}
int32_t maxSize = edn_min(m_AnchorList[localID].m_displaySize.y, MAX_LINE_DISPLAYABLE_BY_BUFFER);
if (offset < 0) {
if (-1 * offset < maxSize) {
EDN_DEBUG("move redraw request : ]" << maxSize << "," << -1*offset << "]=]" << maxSize+offset << "," << -1*offset + offset << "]");
for(int32_t iii=maxSize-1; iii >= -1*offset; iii--) {
m_AnchorList[localID].m_redrawLine[iii] = m_AnchorList[localID].m_redrawLine[iii+offset];
}
EDN_DEBUG("move redraw request : [" << 0 << "," << -1*offset << "[=true");
for(int32_t iii=0; iii < -1*offset; iii++) {
m_AnchorList[localID].m_redrawLine[iii] = true;
}
} else {
EDN_WARNING("FORCE a total redraw... 1");
for(int32_t iii=0; iii < maxSize; iii++) {
m_AnchorList[localID].m_redrawLine[iii] = true;
}
}
} else {
if (offset < maxSize) {
EDN_DEBUG("move redraw request : [" << 0 << "," << maxSize-offset << "[=[" << offset << "," << maxSize << "[");
for(int32_t iii=0; iii < maxSize-offset ; iii++) {
m_AnchorList[localID].m_redrawLine[iii] = m_AnchorList[localID].m_redrawLine[iii+offset];
}
// note the -1 is to force the redisplay of the previous of the last line ==> special case of the gtk 3.0 marker to resize the windows
EDN_DEBUG("move redraw request : [" << maxSize-offset-1 << "," << maxSize << "[=true");
for(int32_t iii=maxSize-offset-1; iii < maxSize; iii++) {
m_AnchorList[localID].m_redrawLine[iii] = true;
}
} else {
EDN_WARNING("FORCE a total redraw... 2");
for(int32_t iii=0; iii < maxSize; iii++) {
m_AnchorList[localID].m_redrawLine[iii] = true;
}
}
}
} else {
EDN_ERROR("can not find the real ID in linste.Size()=" << m_AnchorList.Size());
}
}

77
Sources/Buffer/Buffer.h
View File

@@ -31,43 +31,15 @@
#include "charset.h"
#include "Edn.h"
#define MAX_LINE_DISPLAYABLE_BY_BUFFER (200)
extern "C"
{
typedef struct{
uint32_t nbTotalLine; //!< Number of line in the buffer
uint32_t nbTotalColomn; //!< Number of line in the buffer
uint32_t startLineDisplay; //!< First line display.
uint32_t startColomnDisplay; //!< First Colomn displayed
uint32_t diplayableColomn; //!< NB colomn that can be displayed
uint32_t diplayableLine; //!< NB Line that can be displayed
}infoStatBuffer_ts;
typedef struct {
int32_t m_idAnchor; //!< reference id of the anchor (real id of the upper displayer of CodeView)
bool m_curent; //!< set at true if the anchor is a reference with the curent display
int32_t m_lineId; //!< first line ID to display
int32_t m_bufferPos; //!< position of the first lineId
position_ts m_displayStart; //!< start display position
position_ts m_displaySize; //!< size of the curent display
bool m_redrawLine[MAX_LINE_DISPLAYABLE_BY_BUFFER]; //!< List of the current line that must be redisplayed
int32_t m_BufferNumberLineOffset; //!< number of line that might be an ofset on the curent screen
} bufferAnchorReference_ts;
typedef struct {
position_ts m_displayStart; //!< start display position
position_ts m_displaySize; //!< size of the curent display
int32_t m_lineNumber; //!< current line-number id
int32_t m_nbIterationMax; //!< number of cycle needed to end the dispalay
int32_t m_posStart; //!< position of the start of the line
int32_t m_posStop; //!< position of the end of the line
int32_t m_selectionPosStart; //!< position of the selection start
int32_t m_selectionPosStop; //!< position of the selection stop
bool m_redrawLine[MAX_LINE_DISPLAYABLE_BY_BUFFER]; //!< List of the current line that must be redisplayed
int32_t m_BufferNumberLineOffset; //!< number of line that might be an ofset on the curent screen
} bufferAnchor_ts;
}
typedef struct{
uint32_t nbTotalLine; //!< Number of line in the buffer
uint32_t nbTotalColomn; //!< Number of line in the buffer
uint32_t startLineDisplay; //!< First line display.
uint32_t startColomnDisplay; //!< First Colomn displayed
uint32_t diplayableColomn; //!< NB colomn that can be displayed
uint32_t diplayableLine; //!< NB Line that can be displayed
}infoStatBuffer_ts;
class Buffer {
@@ -109,25 +81,22 @@ class Buffer {
virtual void GetInfo(infoStatBuffer_ts &infoToUpdate);
virtual void SetLineDisplay(uint32_t lineNumber);
virtual void DrawLine(DrawerManager &drawer, bufferAnchor_ts &anchor);
virtual void DrawLineEmpty(DrawerManager &drawer, int32_t lineScreenID);
// return the new cursor position ...
virtual int32_t Display(DrawerManager &drawer);
virtual void ForceReDraw(bool allElement);
virtual void AddChar(char * UTF8data);
virtual void cursorMove(int32_t gtkKey);
virtual void MouseSelectFromCursorTo(int32_t width, int32_t height);
virtual void MouseEvent(int32_t width, int32_t height);
virtual void MouseEventDouble(void);
virtual void MouseEventTriple(void);
virtual void ScrollDown(void);
virtual void ScrollUp(void);
virtual void RemoveLine(void);
virtual void SelectAll(void);
virtual void SelectNone(void);
virtual void Undo(void);
virtual void Redo(void);
virtual void SetCharset(charset_te newCharset) {};
virtual void ScrollDown(void); // must be deprecated
virtual void ScrollUp(void); // must be deprecated
//virtual void SelectAll(void);
virtual void Copy(int8_t clipboardID);
@@ -144,28 +113,6 @@ class Buffer {
// naming
Edn::File m_fileName; //!< filename of the curent buffer
bool m_haveName; //!< to know if the file have a name or NOT
// anchor section
public:
void AnchorAdd(int32_t anchorID);
void AnchorRm(int32_t anchorID);
void AnchorRedrawAll(int32_t anchorID);
virtual bool AnchorGet(int32_t anchorID, bufferAnchor_ts & anchor);
virtual bool AnchorNext(bufferAnchor_ts & anchor);
void AnchorSetSize(int32_t anchorID, int32_t sizePixelX, int32_t sizePixelY);
void AnchorSetStartOffset(int32_t anchorID, int32_t offsetX, int32_t offsetY);
protected:
int32_t m_lineWidth;
int32_t m_lineHeight;
int32_t AnchorRealId(int32_t anchorID);
int32_t AnchorCurrentId(void);
void AnchorForceRedrawAll(int32_t realAnchorId = -5000);
void AnchorForceRedrawLine(int32_t lineID);
void AnchorForceRedrawOffsef(int32_t offset);
Edn::VectorType<bufferAnchorReference_ts> m_AnchorList; //!< list of all line anchor in the current buffer
int32_t m_uniqueID;
};

71
Sources/Buffer/BufferEmpty.cpp
View File

@@ -42,8 +42,7 @@
*/
BufferEmpty::BufferEmpty()
{
m_lineWidth = Display::GetFontWidth();
m_lineHeight = Display::GetFontHeight()*4;
}
/**
@@ -68,58 +67,32 @@ BufferEmpty::~BufferEmpty(void)
* @return ---
*
*/
void BufferEmpty::DrawLine(DrawerManager &drawer, bufferAnchor_ts &anchor)
int32_t BufferEmpty::Display(DrawerManager &drawer)
{
EDN_DEBUG("Request draw : " << anchor.m_lineNumber);
ColorizeManager * myColorManager = ColorizeManager::getInstance();
// Get color :
Colorize *myColor = NULL;
if (anchor.m_lineNumber == 0) {
// Clean Buffer
drawer.Clean(myColorManager->Get(COLOR_CODE_BASIC_BG) );
myColor = myColorManager->Get("normal");
drawer.Text(myColor, 20,20, "edn - Editeur De N'ours, l'Editeur Desoxyribo-Nucleique");
}
if (anchor.m_lineNumber == 1) {
myColor = myColorManager->Get("commentDoxygen");
drawer.Text(myColor, 20,25 + Display::GetFontHeight(), "No Buffer Availlable to display");
}
return;
// Clean Buffer
drawer.Clean(myColorManager->Get(COLOR_CODE_BASIC_BG) );
myColor = myColorManager->Get("normal");
// Draw the 2 comments Lines :
drawer.Text(myColor, 20,20, "edn - Editeur De N'ours, l'Editeur Desoxyribo-Nucleique");
//drawer.Flush();
myColor = myColorManager->Get("commentDoxygen");
drawer.Text(myColor, 20,25 + Display::GetFontHeight(), "No Buffer Availlable to display");
drawer.Flush();
/*
myColor = myColorManager->Get(("SelectedText"));
drawer.Cursor(20, 50);
drawer.EndOfLine(20, 70);
drawer.Tabulation(myColor, 20, 90, 5);
drawer.UTF8UnknownElement(myColor, 20, 120, 3, false);
drawer.Flush();
*/
return ERR_NONE;
}
bool BufferEmpty::AnchorGet(int32_t anchorID, bufferAnchor_ts & anchor)
{
int32_t localID = AnchorRealId(anchorID);
if (localID >=0) {
EDN_DEBUG("Request anchor");
anchor.m_displaySize.x = m_AnchorList[localID].m_displaySize.x;
anchor.m_displaySize.y = m_AnchorList[localID].m_displaySize.y;
anchor.m_displayStart.x = m_AnchorList[localID].m_displayStart.x;
anchor.m_displayStart.y = m_AnchorList[localID].m_displayStart.y;
anchor.m_nbIterationMax = 2;
anchor.m_lineNumber = m_AnchorList[localID].m_lineId;
anchor.m_posStart = -1;
anchor.m_posStop = -1;
anchor.m_selectionPosStart = -1;
anchor.m_selectionPosStop = -1;
return true;
} else {
return false;
}
}
bool BufferEmpty::AnchorNext(bufferAnchor_ts & anchor)
{
anchor.m_lineNumber++;
EDN_DEBUG("Anchor Next : " << anchor.m_lineNumber);
anchor.m_nbIterationMax--;
if (anchor.m_nbIterationMax<=0) {
return false;
}
return true;
}

6
Sources/Buffer/BufferEmpty.h
View File

@@ -32,10 +32,8 @@ class BufferEmpty : public Buffer {
public:
BufferEmpty(void);
virtual ~BufferEmpty(void);
void DrawLine(DrawerManager &drawer, bufferAnchor_ts &anchor);
bool AnchorGet(int32_t anchorID, bufferAnchor_ts & anchor);
bool AnchorNext(bufferAnchor_ts & anchor);
virtual int32_t Display(DrawerManager &drawer);
};

632
Sources/Buffer/BufferText.cpp
View File

@@ -42,6 +42,8 @@ extern "C"
const char * g_pointerForTheDisplayLine[] = {"%1d", "%2d","%3d","%4d","%5d","%6d","%7d","%8d","%9d","%d"};
}
/**
* @brief
*
@@ -52,19 +54,27 @@ extern "C"
*/
void BufferText::BasicInit(void)
{
NeedToCleanEndPage = true;
// set the first element that is displayed
m_displayStartBufferPos = 0;
// set the number of the lineNumber;
m_nbColoneForLineNumber = 1;
nbColoneForLineNumber = 1;
// init the link with the buffer manager
myColorManager = ColorizeManager::getInstance();
// Init Selection mode :
SelectionEnd();
//EDN_INFO("Init");
// new mode :
m_cursorPos = 0;
m_cursorPosPrevious = m_cursorPos;
m_cursorPreferredCol = -1;
m_cursorOn = true;
// set at the sustem buffer internal
m_lineWidth = Display::GetFontWidth();
m_lineHeight = Display::GetFontHeight();
//m_cursorMode = CURSOR_DISPLAY_MODE_NORMAL;
m_displayStart.x = 0;
m_displayStart.y = 0;
m_displaySize.x = 200;
m_displaySize.y = 20;
m_displayLocalSyntax.idSequence = -1;
}
@@ -87,6 +97,7 @@ void BufferText::NameChange(void)
m_EdnBuf.SetHLSystem(myHL);
}
}
}
@@ -134,6 +145,7 @@ BufferText::BufferText(Edn::File &fileName) : Buffer(fileName)
SetModify(true);
}
UpdateWindowsPosition();
ForceReDraw(true);
}
@@ -173,6 +185,28 @@ BufferText::~BufferText(void)
}
void BufferText::SelectionStart(void)
{
// start a nex selection
SelectionCheckMode();
//EDN_DEBUG("SELECT_start");
}
void BufferText::SelectionEnd(void)
{
//EDN_DEBUG("SELECT_stop");
}
void BufferText::SelectionCheckMode(void)
{
/*
if (true == globals::IsSetCtrl() ) {
} else {
}
*/
}
/**
* @brief
*
@@ -183,7 +217,7 @@ BufferText::~BufferText(void)
*/
void BufferText::GetInfo(infoStatBuffer_ts &infoToUpdate)
{
EDN_WARNING("TODO ...");
}
/**
@@ -196,17 +230,13 @@ void BufferText::GetInfo(infoStatBuffer_ts &infoToUpdate)
*/
void BufferText::SetLineDisplay(uint32_t lineNumber)
{
EDN_WARNING("TODO ...");
}
void BufferText::DrawLineNumber(DrawerManager &drawer, int32_t lineNumber, int32_t positionY)
void BufferText::DrawLineNumber(DrawerManager &drawer,char *myPrint, int32_t lineNumber, int32_t positionY)
{
int32_t letterHeight = Display::GetFontHeight();
char tmpLineNumber[50];
sprintf(tmpLineNumber, g_pointerForTheDisplayLine[m_nbColoneForLineNumber-1], lineNumber);
sprintf(tmpLineNumber, myPrint, lineNumber);
drawer.Text(myColorManager->Get(COLOR_CODE_LINE_NUMBER), 1, positionY, tmpLineNumber);
}
@@ -218,6 +248,7 @@ void BufferText::DrawLineNumber(DrawerManager &drawer, int32_t lineNumber, int32
* @return ---
*
*/
/*
void BufferText::UpdatePointerNumber(void)
{
// get the number of line in the buffer
@@ -235,146 +266,208 @@ void BufferText::UpdatePointerNumber(void)
} else { m_nbColoneForLineNumber = 10;
}
}
void BufferText::DrawLine(DrawerManager &drawer, bufferAnchor_ts &anchor)
*/
/**
* @brief Display the curent buffer with all the probematic imposed by the xharset and the user contraint.
*
* @param[in,out] drawer the basic user drawer of EDN.
*
* @return
*
*/
int32_t BufferText::Display(DrawerManager &drawer)
{
int32_t letterHeight = Display::GetFontHeight();
int32_t letterWidth = Display::GetFontWidth();
int32_t positionY = letterHeight * (anchor.m_lineNumber - anchor.m_displayStart.y - 1);
int32_t idX = 0;
int32_t pixelX = m_nbColoneForLineNumber*letterWidth + 3;
Colorize * myColorNormal = myColorManager->Get("normal");
Colorize * myColorSelected = myColorManager->Get("SelectedText");
Colorize * selectColor = NULL;
// update the number of element that can be displayed
m_displaySize.x = (drawer.GetWidth()/letterWidth) + 1 - nbColoneForLineNumber;;
m_displaySize.y = (drawer.GetHeight()/letterHeight) + 1;
EDN_INFO("main DIPLAY " << m_displaySize.x << " char * " << m_displaySize.y << " char");
int32_t selStart, selEnd, selRectStart, selRectEnd;
bool selIsRect;
int32_t selHave = m_EdnBuf.GetSelectionPos(SELECTION_PRIMARY, selStart, selEnd, selIsRect, selRectStart, selRectEnd);
colorInformation_ts * HLColor = NULL;
// Regenerate the colorizing if necessary ...
displayHLData_ts myDisplayLocalSyntax;
m_EdnBuf.HightlightOneLine(myDisplayLocalSyntax, anchor.m_posStart, anchor.m_posStop);
//displayLineNumber(drawer);
// get the number of line in the buffer
int32_t maxNumberLine = m_EdnBuf.NumberOfLines();
//int32_t maxNumberLine = 2096;
char *myPrint = NULL;
if (10 > maxNumberLine) { nbColoneForLineNumber = 1; myPrint = (char *)"%1d";
} else if (100 > maxNumberLine) { nbColoneForLineNumber = 2; myPrint = (char *)"%2d";
} else if (1000 > maxNumberLine) { nbColoneForLineNumber = 3; myPrint = (char *)"%3d";
} else if (10000 > maxNumberLine) { nbColoneForLineNumber = 4; myPrint = (char *)"%4d";
} else if (100000 > maxNumberLine) { nbColoneForLineNumber = 5; myPrint = (char *)"%5d";
} else if (1000000 > maxNumberLine) { nbColoneForLineNumber = 6; myPrint = (char *)"%6d";
} else if (1000000 > maxNumberLine) { nbColoneForLineNumber = 7; myPrint = (char *)"%7d";
} else if (10000000 > maxNumberLine) { nbColoneForLineNumber = 8; myPrint = (char *)"%8d";
} else if (100000000 > maxNumberLine) { nbColoneForLineNumber = 9; myPrint = (char *)"%9d";
} else { nbColoneForLineNumber = 10; myPrint = (char *)"%d";
}
// clean the current Line
drawer.Rectangle(myColorManager->Get(COLOR_CODE_BASIC_BG), 0, positionY, drawer.GetWidth(), letterHeight);
DrawLineNumber(drawer, anchor.m_lineNumber, positionY);
bool selHave = anchor.m_selectionPosStart == -1 ? false : true;
uint32_t y = 0;
int32_t iii, new_i;
// Get color :
Colorize * myColor = myColorManager->Get("normal");
Colorize * myColorSel = myColorManager->Get("SelectedText");
color_ts & myColorSpace = myColorManager->Get(COLOR_CODE_SPACE);
color_ts & myColorTab = myColorManager->Get(COLOR_CODE_TAB);
Colorize * selectColor = NULL;
char displayChar[MAX_EXP_CHAR_LEN];
memset(displayChar, 0, sizeof(char)*MAX_EXP_CHAR_LEN);
int32_t iii;
for (iii=anchor.m_posStart; iii<anchor.m_posStop; ) {
uint32_t currentChar;
int32_t savePositionForCursor = iii;
int32_t displaywidth = m_EdnBuf.GetExpandedChar(iii, idX, displayChar, currentChar);
selectColor = myColorNormal;
//kwow size to display
int32_t widthToDisplay;
char * tmpDisplayOfset;
bool inTheScreen = true;
if (anchor.m_displayStart.x <= idX) {
// Normal display
tmpDisplayOfset = displayChar;
widthToDisplay = displaywidth;
} else if (anchor.m_displayStart.x < idX + displaywidth) {
// special case of partial display :
widthToDisplay = idX + displaywidth - anchor.m_displayStart.x;
tmpDisplayOfset = displayChar + (displaywidth-widthToDisplay);
} else {
// Out of range ...
widthToDisplay = displaywidth;
tmpDisplayOfset = displayChar;
inTheScreen = false;
}
if (true==inTheScreen) {
HLColor = m_EdnBuf.GetElementColorAtPosition(myDisplayLocalSyntax, savePositionForCursor);
if (NULL != HLColor) {
if (NULL != HLColor->patern) {
selectColor = HLColor->patern->GetColor();
}
}
// If user want to display space char : overwrite curent color
if( ' ' == currentChar
&& true == globals::IsSetDisplaySpaceChar() )
{
//selectColor = myColorSelected;
//SpaceText(color_ts & SelectColor, int32_t x, int32_t y,int32_t nbChar)
if( true == selHave
&& anchor.m_selectionPosStart <= iii
&& anchor.m_selectionPosStop > iii)
{
drawer.SpaceText(myColorSelected->GetBG(), pixelX ,positionY , 1);
} else if (true == selectColor->HaveBg()) {
drawer.SpaceText(selectColor->GetBG(), pixelX ,positionY , 1);
} else {
drawer.SpaceText(myColorManager->Get(COLOR_CODE_SPACE), pixelX ,positionY , 1);
}
} else if( '\t' == currentChar
&& true == globals::IsSetDisplaySpaceChar() )
{
if( true == selHave
&& anchor.m_selectionPosStart <= iii
&& anchor.m_selectionPosStop > iii)
{
drawer.SpaceText(myColorSelected->GetBG(), pixelX ,positionY , strlen(tmpDisplayOfset));
} else if (true == selectColor->HaveBg()) {
drawer.SpaceText(selectColor->GetBG(), pixelX ,positionY , strlen(tmpDisplayOfset));
} else {
drawer.SpaceText(myColorManager->Get(COLOR_CODE_TAB), pixelX ,positionY , strlen(tmpDisplayOfset));
}
int mylen = m_EdnBuf.Size();
int32_t x_base=nbColoneForLineNumber*letterWidth + 3;
uint32_t xx = 0;
int32_t idX = 0;
drawer.Clean(myColorManager->Get(COLOR_CODE_BASIC_BG));
int displayLines = 0;
// Regenerate the colorizing if necessary ...
m_EdnBuf.HightlightGenerateLines(m_displayLocalSyntax, m_displayStartBufferPos, m_displaySize.y);
GTimeVal timeStart;
g_get_current_time(&timeStart);
// draw the lineNumber :
int32_t currentLineID = m_displayStart.y+1;
DrawLineNumber(drawer, myPrint, currentLineID, y);
for (iii=m_displayStartBufferPos; iii<mylen && displayLines < m_displaySize.y ; iii = new_i) {
//EDN_INFO("diplay element=" << iii);
int32_t pixelX = xx*letterWidth + x_base;
int displaywidth;
uint32_t currentChar = '\0';
new_i = iii;
displaywidth = m_EdnBuf.GetExpandedChar(new_i, idX, displayChar, currentChar);
//EDN_INFO("diplay element=" << new_i);
if (currentChar!='\n') {
selectColor = myColor;
//kwow size to display
int32_t widthToDisplay;
char * tmpDisplayOfset;
bool inTheScreen = true;
if (m_displayStart.x <= idX) {
// Normal display
tmpDisplayOfset = displayChar;
widthToDisplay = displaywidth;
} else if (m_displayStart.x < idX + displaywidth) {
// special case of partial display :
widthToDisplay = idX + displaywidth - m_displayStart.x;
tmpDisplayOfset = displayChar + (displaywidth-widthToDisplay);
} else {
if( true == selHave
&& anchor.m_selectionPosStart <= iii
&& anchor.m_selectionPosStop > iii)
{
selectColor = myColorSelected;
}
if (currentChar <= 0x7F) {
drawer.Text(selectColor, pixelX ,positionY, tmpDisplayOfset);
} else {
drawer.Text(selectColor, pixelX ,positionY, displayChar);
}
// Out of range ...
widthToDisplay = displaywidth;
tmpDisplayOfset = displayChar;
inTheScreen = false;
}
if (true==inTheScreen) {
HLColor = m_EdnBuf.GetElementColorAtPosition(m_displayLocalSyntax, iii);
if (NULL != HLColor) {
if (NULL != HLColor->patern) {
selectColor = HLColor->patern->GetColor();
}
}
// If user want to display space char : overwrite curent color
if( ' ' == currentChar
&& true == globals::IsSetDisplaySpaceChar() )
{
//selectColor = myColorSel;
//SpaceText(color_ts & SelectColor, int32_t x, int32_t y,int32_t nbChar)
if( true == selHave
&& selStart <= iii
&& selEnd > iii)
{
drawer.SpaceText(myColorSel->GetBG(), pixelX ,y , 1);
} else if (true == selectColor->HaveBg()) {
drawer.SpaceText(selectColor->GetBG(), pixelX ,y , 1);
} else {
drawer.SpaceText(myColorSpace, pixelX ,y , 1);
}
} else if( '\t' == currentChar
&& true == globals::IsSetDisplaySpaceChar() )
{
if( true == selHave
&& selStart <= iii
&& selEnd > iii)
{
drawer.SpaceText(myColorSel->GetBG(), pixelX ,y , strlen(tmpDisplayOfset));
} else if (true == selectColor->HaveBg()) {
drawer.SpaceText(selectColor->GetBG(), pixelX ,y , strlen(tmpDisplayOfset));
} else {
drawer.SpaceText(myColorTab, pixelX ,y , strlen(tmpDisplayOfset));
}
} else {
if( true == selHave
&& selStart <= iii
&& selEnd > iii)
{
selectColor = myColorSel;
}
if (currentChar <= 0x7F) {
drawer.Text(selectColor, pixelX ,y, tmpDisplayOfset);
} else {
drawer.Text(selectColor, pixelX ,y, displayChar);
}
}
xx+=widthToDisplay;
}
idX += displaywidth;
}
// display cursor :
if (m_cursorPos == savePositionForCursor) {
if (m_cursorPos == iii) {
// display the cursor:
if (true == m_cursorOn) {
drawer.Cursor(pixelX, positionY+letterHeight);
drawer.Cursor(pixelX, y+letterHeight);
//m_cursorOn = false;
} else {
m_cursorOn = true;
}
}
if (true==inTheScreen) {
pixelX += widthToDisplay*letterWidth;
// move to next line ...
if (currentChar=='\n') {
drawer.EndOfLine(pixelX, y+letterHeight);
drawer.Flush();
xx = 0;
idX =0;
y += letterHeight;
displayLines++;
currentLineID++;
DrawLineNumber(drawer, myPrint, currentLineID, y);
}
idX += displaywidth;
}
// special case : the cursor is at the end of the buffer...
if (m_cursorPos == iii) {
// display the cursor:
if (true == m_cursorOn) {
drawer.Cursor(pixelX, positionY+letterHeight);
//m_cursorOn = false;
drawer.Cursor(xx*letterWidth + x_base, y+letterHeight);
m_cursorOn = false;
} else {
m_cursorOn = true;
}
}
drawer.Flush();
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_DEBUG("Display Generation = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s");
return ERR_NONE;
}
void BufferText::GetMousePosition(int32_t width, int32_t height, int32_t &x, int32_t &y)
{
x = (width - 3) / Display::GetFontWidth() - m_nbColoneForLineNumber;
x = (width - 3) / Display::GetFontWidth() - nbColoneForLineNumber;
y = height / Display::GetFontHeight();
if (x < 0) {
x = 0;
}
x += m_AnchorList[AnchorCurrentId()].m_displayStart.x;
y += m_AnchorList[AnchorCurrentId()].m_displayStart.y;
x += m_displayStart.x;
y += m_displayStart.y;
//EDN_DEBUG("BufferText::GetMousePosition(" << width << "," << height << "); ==> (" << x << "," << y << ")" );
}
@@ -408,11 +501,8 @@ void BufferText::MouseEvent(int32_t width, int32_t height)
m_cursorPreferredCol = posX;
}
m_EdnBuf.Unselect(SELECTION_PRIMARY);
/*
// for the redraw to permit to remove display error ...
AnchorForceRedrawAll();
*/
ForceReDraw(true);
UpdateWindowsPosition();
}
}
@@ -462,6 +552,7 @@ void BufferText::MouseSelectFromCursorTo(int32_t width, int32_t height)
m_EdnBuf.Select(SELECTION_PRIMARY, selStart, m_cursorPos);
}
}
ForceReDraw(true);
UpdateWindowsPosition();
}
@@ -480,8 +571,8 @@ void BufferText::MouseEventDouble(void)
int32_t beginPos, endPos;
if (true == m_EdnBuf.SelectAround(m_cursorPos, beginPos, endPos)) {
m_EdnBuf.Select(SELECTION_PRIMARY, beginPos, endPos);
m_cursorPosPrevious = m_cursorPos;
m_cursorPos = endPos;
ForceReDraw(true);
}
// no else
}
@@ -497,8 +588,8 @@ void BufferText::MouseEventDouble(void)
void BufferText::MouseEventTriple(void)
{
m_EdnBuf.Select(SELECTION_PRIMARY, m_EdnBuf.StartOfLine(m_cursorPos), m_EdnBuf.EndOfLine(m_cursorPos));
m_cursorPosPrevious = m_cursorPos;
m_cursorPos = m_EdnBuf.EndOfLine(m_cursorPos);
ForceReDraw(true);
}
void BufferText::RemoveLine(void)
@@ -506,29 +597,23 @@ void BufferText::RemoveLine(void)
int32_t start = m_EdnBuf.StartOfLine(m_cursorPos);
int32_t stop = m_EdnBuf.EndOfLine(m_cursorPos);
m_EdnBuf.Remove(start, stop+1);
// for the redraw to permit to remove display error ...
AnchorForceRedrawAll();
SetInsertPosition(start);
SetModify(true);
SetModify(true);
}
void BufferText::SelectAll(void)
{
m_EdnBuf.Select(SELECTION_PRIMARY, 0, m_EdnBuf.Size());
m_cursorPosPrevious = m_cursorPos;
m_cursorPos = m_EdnBuf.Size();
AnchorForceRedrawAll();
ForceReDraw(true);
}
void BufferText::SelectNone(void)
{
m_EdnBuf.Unselect(SELECTION_PRIMARY);
// for the redraw to permit to remove display error ...
AnchorForceRedrawAll();
ForceReDraw(true);
}
#define SCROLL_NB_LINE (3)
/**
* @brief
*
@@ -539,7 +624,7 @@ void BufferText::SelectNone(void)
*/
void BufferText::ScrollDown(void)
{
MoveUpDown(SCROLL_NB_LINE);
MoveUpDown(3);
}
@@ -553,7 +638,7 @@ void BufferText::ScrollDown(void)
*/
void BufferText::ScrollUp(void)
{
MoveUpDown(-1 * SCROLL_NB_LINE);
MoveUpDown(-3);
}
@@ -567,35 +652,44 @@ void BufferText::ScrollUp(void)
*/
void BufferText::MoveUpDown(int32_t ofset)
{
int32_t iii=AnchorCurrentId();
m_displayLocalSyntax.idSequence = -1;
if (ofset >= 0) {
int32_t nbLine = m_EdnBuf.NumberOfLines();
if (m_AnchorList[iii].m_displayStart.y+ofset+3 > nbLine) {
m_AnchorList[iii].m_displayStart.y = nbLine-3;
AnchorForceRedrawOffsef(m_AnchorList[iii].m_displayStart.y-(nbLine-3));
if (m_displayStart.y+ofset+3 > nbLine) {
m_displayStart.y = nbLine-3;
} else {
AnchorForceRedrawOffsef(ofset);
m_AnchorList[iii].m_displayStart.y += ofset;
m_displayStart.y += ofset;
}
m_AnchorList[iii].m_bufferPos = m_EdnBuf.CountForwardNLines(0, m_AnchorList[iii].m_displayStart.y);
m_AnchorList[iii].m_lineId = m_AnchorList[iii].m_displayStart.y;
m_displayStartBufferPos = m_EdnBuf.CountForwardNLines(0, m_displayStart.y);
} else {
ofset *= -1;
if (m_AnchorList[iii].m_displayStart.y < ofset) {
AnchorForceRedrawOffsef(-1 * m_AnchorList[iii].m_displayStart.y);
m_AnchorList[iii].m_displayStart.y = 0;
m_AnchorList[iii].m_bufferPos = 0;
m_AnchorList[iii].m_lineId = 0;
if (m_displayStart.y < ofset) {
m_displayStart.y = 0;
m_displayStartBufferPos = 0;
} else {
AnchorForceRedrawOffsef(-1 * ofset);
m_AnchorList[iii].m_displayStart.y -= ofset;
m_AnchorList[iii].m_bufferPos = m_EdnBuf.CountForwardNLines(0, m_AnchorList[iii].m_displayStart.y);
m_AnchorList[iii].m_lineId = m_AnchorList[iii].m_displayStart.y;
m_displayStart.y -= ofset;
m_displayStartBufferPos = m_EdnBuf.CountForwardNLines(0, m_displayStart.y);
}
}
}
/**
* @brief
*
* @param[in,out] ---
*
* @return ---
*
*/
void BufferText::ForceReDraw(bool allElement)
{
NeedToCleanEndPage = true;
//m_displayLocalSyntax.idSequence = -1;
}
void BufferText::SetInsertPosition(int32_t newPos, bool insertChar)
{
int32_t SelectionStart, SelectionEnd, SelectionRectStart, SelectionRectEnd;
@@ -604,6 +698,7 @@ void BufferText::SetInsertPosition(int32_t newPos, bool insertChar)
int32_t rememberCursorPos = m_cursorPos;
//EDN_DEBUG("newPos=" << newPos);
// unselect buffer:
m_EdnBuf.Unselect(SELECTION_PRIMARY);
/* make sure new position is ok, do nothing if it hasn't changed */
@@ -614,7 +709,6 @@ void BufferText::SetInsertPosition(int32_t newPos, bool insertChar)
if (newPos > m_EdnBuf.Size()) {
newPos = m_EdnBuf.Size();
}
m_cursorPosPrevious = m_cursorPos;
m_cursorPos = newPos;
}
m_cursorPreferredCol = -1;
@@ -721,8 +815,19 @@ bool BufferText::TextDMoveDown(int32_t offset)
*/
void BufferText::cursorMove(int32_t gtkKey)
{
int32_t tmplineID;
bool needUpdatePosition = true;
// check selection event ...
/*
if (true == globals::IsSetShift() ) {
if ( CURSOR_MODE_NORMAL == cursorMode) {
SelectionStart();
} else {
SelectionCheckMode();
}
} else {
SelectionEnd();
}
*/
switch(gtkKey) {
# ifdef USE_GTK_VERSION_3_0
case GDK_KEY_Left:
@@ -767,7 +872,7 @@ void BufferText::cursorMove(int32_t gtkKey)
case GDK_Page_Up:
# endif
//EDN_INFO("keyEvent : <PAGE-UP>");
TextDMoveUp(m_AnchorList[AnchorCurrentId()].m_displaySize.y);
TextDMoveUp(m_displaySize.y);
break;
# ifdef USE_GTK_VERSION_3_0
case GDK_KEY_Page_Down:
@@ -775,7 +880,7 @@ void BufferText::cursorMove(int32_t gtkKey)
case GDK_Page_Down:
# endif
//EDN_INFO("keyEvent : <PAGE-DOWN>");
TextDMoveDown(m_AnchorList[AnchorCurrentId()].m_displaySize.y);
TextDMoveDown(m_displaySize.y);
break;
# ifdef USE_GTK_VERSION_3_0
case GDK_KEY_Begin:
@@ -814,86 +919,57 @@ void BufferText::cursorMove(int32_t gtkKey)
*/
void BufferText::UpdateWindowsPosition(bool centerPage)
{
int32_t iii = AnchorCurrentId();
if (iii >=0) {
int32_t linePreviousID = m_EdnBuf.GetLinesIdWithRef(m_cursorPosPrevious, m_AnchorList[iii].m_bufferPos, m_AnchorList[iii].m_lineId);
AnchorForceRedrawLine(linePreviousID);
if (centerPage == false) {
// Display position (Y mode):
//EDN_INFO("BufferText::UpdateWindowsPosition() m_displayStart(" << m_displayStart.x << "," << m_displayStart.y << ") m_displaySize(" << m_displaySize.x << "," <<m_displaySize.y << ")");
position_ts cursorPosition;
cursorPosition.y = m_EdnBuf.CountLines(0, m_cursorPos);
int32_t lineStartPos = m_EdnBuf.StartOfLine(m_cursorPos);
cursorPosition.x = m_EdnBuf.CountDispChars(lineStartPos, m_cursorPos);
//EDN_INFO("BufferText::UpdateWindowsPosition() curent cursor position : (" << cursorPosition.x << "," << cursorPosition.y << ")");
if (centerPage == false) {
// Display position (Y mode):
int32_t lineStartPos;
// Get current position of cursor :
position_ts cursorPosition;
EDN_WARNING("plop");
cursorPosition.y = m_EdnBuf.GetLinesIdWithRef(m_cursorPos, m_AnchorList[iii].m_bufferPos, m_AnchorList[iii].m_lineId);
AnchorForceRedrawLine(cursorPosition.y);
lineStartPos = m_EdnBuf.StartOfLine(m_cursorPos);
cursorPosition.x = m_EdnBuf.CountDispChars(lineStartPos, m_cursorPos);
//EDN_INFO(" curent cursor position : (" << cursorPosition.x << "," << cursorPosition.y << ")");
position_ts displayPreviousStart = m_AnchorList[iii].m_displayStart;
//EDN_INFO(" m_displayStart(" << m_AnchorList[iii].m_displayStart.x << "," << m_AnchorList[iii].m_displayStart.y << ") m_displaySize(" << m_AnchorList[iii].m_displaySize.x << "," << m_AnchorList[iii].m_displaySize.y << ")");
if (m_AnchorList[iii].m_displayStart.y > (int32_t)cursorPosition.y - globals::getNbLineBorder() ) {
m_AnchorList[iii].m_displayStart.y = cursorPosition.y - globals::getNbLineBorder();
if (m_AnchorList[iii].m_displayStart.y < 0) {
m_AnchorList[iii].m_displayStart.y = 0;
}
} else if (m_AnchorList[iii].m_displayStart.y + m_AnchorList[iii].m_displaySize.y <= (int32_t)cursorPosition.y + globals::getNbLineBorder() ) {
m_AnchorList[iii].m_displayStart.y = cursorPosition.y - m_AnchorList[iii].m_displaySize.y + globals::getNbLineBorder() + 1;
if (m_displayStart.y > (int32_t)cursorPosition.y - globals::getNbLineBorder() ) {
m_displayStart.y = cursorPosition.y - globals::getNbLineBorder();
if (m_displayStart.y < 0) {
m_displayStart.y = 0;
ForceReDraw(true);
}
// Display position (X mode):
//EDN_INFO("cursorPosition X : " << cursorPosition.y << " windows " << m_displayStart.y << "=>" << m_displayStart.x + m_displaySize.x);
if (m_AnchorList[iii].m_displayStart.x > cursorPosition.x - globals::getNbColoneBorder() ) {
m_AnchorList[iii].m_displayStart.x = cursorPosition.x - globals::getNbColoneBorder();
if (m_AnchorList[iii].m_displayStart.x < 0) {
m_AnchorList[iii].m_displayStart.x = 0;
}
} else if (m_AnchorList[iii].m_displayStart.x + m_AnchorList[iii].m_displaySize.x <= cursorPosition.x + globals::getNbColoneBorder() ) {
m_AnchorList[iii].m_displayStart.x = cursorPosition.x - m_AnchorList[iii].m_displaySize.x + globals::getNbColoneBorder() + 1;
}
//update the buffer position ID :
m_AnchorList[iii].m_bufferPos = m_EdnBuf.CountForwardNLines(0, m_AnchorList[iii].m_displayStart.y);
m_AnchorList[iii].m_lineId = m_AnchorList[iii].m_displayStart.y;
if (m_AnchorList[iii].m_displayStart.x != displayPreviousStart.x) {
AnchorForceRedrawAll(iii);
} else {
if (m_AnchorList[iii].m_displayStart.y != displayPreviousStart.y) {
//EDN_WARNING("SELECT an ofset : displayPreviousStart.y=" << displayPreviousStart.y << " m_AnchorList[iii].m_displayStart.y=" << m_AnchorList[iii].m_displayStart.y << " ==>" << m_AnchorList[iii].m_displayStart.y - displayPreviousStart.y);
//EDN_WARNING("SELECT ... offset = " << m_AnchorList[iii].m_BufferNumberLineOffset);
AnchorForceRedrawOffsef(m_AnchorList[iii].m_displayStart.y - displayPreviousStart.y);
//EDN_WARNING("SELECT ... offset = " << m_AnchorList[iii].m_BufferNumberLineOffset);
}
int32_t SelectionStart, SelectionEnd, SelectionRectStart, SelectionRectEnd;
bool SelectionIsRect;
bool haveSelectionActive = m_EdnBuf.GetSelectionPos(SELECTION_PRIMARY, SelectionStart, SelectionEnd, SelectionIsRect, SelectionRectStart, SelectionRectEnd);
if (true == haveSelectionActive) {
int32_t start = edn_min(linePreviousID, cursorPosition.y);
int32_t stop = edn_max(linePreviousID, cursorPosition.y);
//EDN_WARNING("SELECT force redraw range of lines : (" << start << "," << stop << ")");
for (int32_t jjj=start; jjj <= stop; jjj++) {
AnchorForceRedrawLine(jjj);
}
}
}
} else {
// center the line at the middle of the screen :
position_ts cursorPosition;
//EDN_DEBUG(" -------------------------------------------------");
cursorPosition.y = m_EdnBuf.GetLinesIdWithRef(m_cursorPos, m_AnchorList[iii].m_bufferPos, m_AnchorList[iii].m_lineId);
//EDN_DEBUG(" cursor position : " << m_cursorPos << " ==> ligne=" << cursorPosition.y);
cursorPosition.x = 0;
m_AnchorList[iii].m_displayStart.x = 0;
//EDN_DEBUG(" display size : " << m_displaySize.y);
m_AnchorList[iii].m_displayStart.y = cursorPosition.y - m_AnchorList[iii].m_displaySize.y/2;
m_AnchorList[iii].m_displayStart.y = edn_max(m_AnchorList[iii].m_displayStart.y, 0);
m_AnchorList[iii].m_bufferPos = m_EdnBuf.CountForwardNLines(0, m_AnchorList[iii].m_displayStart.y);
m_AnchorList[iii].m_lineId = m_AnchorList[iii].m_displayStart.y;
//EDN_DEBUG(" display start : " << m_displayStart.x << "x" << m_displayStart.y);
//EDN_DEBUG(" -------------------------------------------------");
AnchorForceRedrawAll(iii);
} else if (m_displayStart.y + m_displaySize.y <= (int32_t)cursorPosition.y + globals::getNbLineBorder() ) {
m_displayStart.y = cursorPosition.y - m_displaySize.y + globals::getNbLineBorder() + 1;
ForceReDraw(true);
}
// Display position (X mode):
//EDN_INFO("cursorPosition X : " << cursorPosition.y << " windows " << m_displayStart.y << "=>" << m_displayStart.x + m_displaySize.x);
if (m_displayStart.x > cursorPosition.x - globals::getNbColoneBorder() ) {
m_displayStart.x = cursorPosition.x - globals::getNbColoneBorder();
if (m_displayStart.x < 0) {
m_displayStart.x = 0;
ForceReDraw(true);
}
} else if (m_displayStart.x + m_displaySize.x <= cursorPosition.x + globals::getNbColoneBorder() ) {
m_displayStart.x = cursorPosition.x - m_displaySize.x + globals::getNbColoneBorder() + 1;
ForceReDraw(true);
}
//update the buffer position ID :
m_displayStartBufferPos = m_EdnBuf.CountForwardNLines(0, m_displayStart.y);
} else {
// center the line at the middle of the screen :
position_ts cursorPosition;
//EDN_DEBUG(" -------------------------------------------------");
cursorPosition.y = m_EdnBuf.CountLines(0, m_cursorPos);
//EDN_DEBUG(" cursor position : " << m_cursorPos << " ==> ligne=" << cursorPosition.y);
cursorPosition.x = 0;
m_displayStart.x = 0;
//EDN_DEBUG(" display size : " << m_displaySize.y);
m_displayStart.y = cursorPosition.y - m_displaySize.y/2;
m_displayStart.y = edn_max(m_displayStart.y, 0);
m_displayStartBufferPos = m_EdnBuf.CountForwardNLines(0, m_displayStart.y);
ForceReDraw(true);
//EDN_DEBUG(" display start : " << m_displayStart.x << "x" << m_displayStart.y);
//EDN_DEBUG(" -------------------------------------------------");
}
}
@@ -931,13 +1007,11 @@ void BufferText::AddChar(char * UTF8data)
m_EdnBuf.ReplaceSelected(SELECTION_PRIMARY, tmpVect);
SetInsertPosition(SelectionStart+tmpVect.Size(), true);
} else {
int32_t tmpPos = m_cursorPos;
if (true == globals::IsSetShift() ) {
tmpPos = m_EdnBuf.UnIndent(SELECTION_PRIMARY);
m_cursorPos = m_EdnBuf.UnIndent(SELECTION_PRIMARY);
} else {
tmpPos = m_EdnBuf.Indent(SELECTION_PRIMARY);
m_cursorPos = m_EdnBuf.Indent(SELECTION_PRIMARY);
}
SetInsertPosition(tmpPos, true);
}
}
actionDone = true;
@@ -997,7 +1071,6 @@ void BufferText::AddChar(char * UTF8data)
}
actionDone = true;
}
AnchorForceRedrawAll();
}
if (false == actionDone) {
@@ -1028,6 +1101,7 @@ void BufferText::AddChar(char * UTF8data)
}
}
}
SetModify(true);
UpdateWindowsPosition();
}
@@ -1057,8 +1131,6 @@ void BufferText::JumpAtLine(int32_t newLine)
{
int32_t positionLine = m_EdnBuf.CountForwardNLines(0, newLine);
m_EdnBuf.Unselect(SELECTION_PRIMARY);
// for the redraw to permit to remove display error ...
AnchorForceRedrawAll();
EDN_DEBUG("jump at the line : " << newLine );
SetInsertPosition(positionLine);
UpdateWindowsPosition(true);
@@ -1212,6 +1284,7 @@ void BufferText::Copy(int8_t clipboardID)
*/
void BufferText::Cut(int8_t clipboardID)
{
int32_t SelectionStart, SelectionEnd, SelectionRectStart, SelectionRectEnd;
bool SelectionIsRect;
bool haveSelectionActive = m_EdnBuf.GetSelectionPos(SELECTION_PRIMARY, SelectionStart, SelectionEnd, SelectionIsRect, SelectionRectStart, SelectionRectEnd);
@@ -1222,11 +1295,10 @@ void BufferText::Cut(int8_t clipboardID)
if (true == haveSelectionActive ) {
EDN_INFO("REMOVE SELECTION");
m_EdnBuf.RemoveSelected(SELECTION_PRIMARY);
SetInsertPosition(SelectionStart, true);
m_cursorPos = SelectionStart;
}
// for the redraw to permit to remove display error ...
AnchorForceRedrawAll();
UpdateWindowsPosition();
ForceReDraw(true);
SetModify(true);
}
@@ -1252,15 +1324,15 @@ void BufferText::Paste(int8_t clipboardID)
if (true == haveSelectionActive ) {
// replace data
m_EdnBuf.ReplaceSelected(SELECTION_PRIMARY, mVect );
SetInsertPosition(SelectionStart + mVect.Size(), true);
m_cursorPos = SelectionStart + mVect.Size();
} else {
// insert data
m_EdnBuf.Insert(m_cursorPos, mVect);
SetInsertPosition(m_cursorPos + mVect.Size(), true);
m_cursorPos += mVect.Size();
}
// for the redraw to permit to remove display error ...
AnchorForceRedrawAll();
UpdateWindowsPosition();
ForceReDraw(true);
SetModify(true);
}
@@ -1271,10 +1343,9 @@ void BufferText::Undo(void)
if (newPos >= 0) {
SetInsertPosition(newPos, true);
UpdateWindowsPosition();
ForceReDraw(true);
SetModify(true);
}
// for the redraw to permit to remove display error ...
AnchorForceRedrawAll();
}
void BufferText::Redo(void)
@@ -1283,80 +1354,15 @@ void BufferText::Redo(void)
if (newPos >= 0) {
SetInsertPosition(newPos, true);
UpdateWindowsPosition();
ForceReDraw(true);
SetModify(true);
}
// for the redraw to permit to remove display error ...
AnchorForceRedrawAll();
}
void BufferText::SetCharset(charset_te newCharset)
{
m_EdnBuf.SetCharsetType(newCharset);
ForceReDraw(true);
}
bool BufferText::AnchorGet(int32_t anchorID, bufferAnchor_ts & anchor)
{
int32_t localID = AnchorRealId(anchorID);
if (localID >=0) {
// update internal sise of the width of lineID
UpdatePointerNumber();
// Updata uper size of display
anchor.m_displaySize.x = m_AnchorList[localID].m_displaySize.x;
anchor.m_displaySize.y = m_AnchorList[localID].m_displaySize.y;
anchor.m_displayStart.x = m_AnchorList[localID].m_displayStart.x;
anchor.m_displayStart.y = m_AnchorList[localID].m_displayStart.y;
anchor.m_nbIterationMax = anchor.m_displaySize.y;
// update to buffer position
anchor.m_lineNumber = m_AnchorList[localID].m_lineId+1;
anchor.m_posStart = m_AnchorList[localID].m_bufferPos;
if (anchor.m_posStart >= m_EdnBuf.Size()+1) {
return false;
}
anchor.m_posStop = m_EdnBuf.EndOfLine(anchor.m_posStart);
// Update selection current
int32_t selStart, selEnd, selRectStart, selRectEnd;
bool selIsRect;
bool selHave = m_EdnBuf.GetSelectionPos(SELECTION_PRIMARY, selStart, selEnd, selIsRect, selRectStart, selRectEnd);
if (false == selHave){
anchor.m_selectionPosStart = -1;
anchor.m_selectionPosStop = -1;
} else {
anchor.m_selectionPosStart = selStart+1;
anchor.m_selectionPosStop = selEnd+1;
}
EDN_DEBUG("SET in anchor " << m_AnchorList[localID].m_displaySize.y << " lines to display");
for(int32_t iii=0; iii</*edn_min(*/m_AnchorList[localID].m_displaySize.y/*, MAX_LINE_DISPLAYABLE_BY_BUFFER)*/; iii++) {
anchor.m_redrawLine[iii] = m_AnchorList[localID].m_redrawLine[iii];
m_AnchorList[localID].m_redrawLine[iii] = false;
/*if (iii > m_AnchorList[localID].m_displaySize.y - 4) {
anchor.m_redrawLine[iii] = true;
}*/
}
anchor.m_BufferNumberLineOffset = m_AnchorList[localID].m_BufferNumberLineOffset;
m_AnchorList[localID].m_BufferNumberLineOffset = 0;
EDN_DEBUG("Request display : line=" << anchor.m_lineNumber << " (" << anchor.m_posStart << "," << anchor.m_posStop << ")");
EDN_DEBUG(" ==> select : (" << anchor.m_selectionPosStart << "," << anchor.m_selectionPosStop << ")");
return true;
} else {
return false;
}
}
bool BufferText::AnchorNext(bufferAnchor_ts & anchor)
{
anchor.m_lineNumber++;
anchor.m_posStart = anchor.m_posStop+1;
if (anchor.m_posStart >= m_EdnBuf.Size()+1) {
return false;
}
anchor.m_posStop = m_EdnBuf.EndOfLine(anchor.m_posStart);
anchor.m_nbIterationMax--;
if (anchor.m_nbIterationMax<0) {
return false;
}
return true;
}

96
Sources/Buffer/BufferText.h
View File

@@ -36,63 +36,65 @@ typedef enum {
CURSOR_DISPLAY_MODE_NOT_FOCUS,
} cursorDisplayMode_te;
class BufferText : public Buffer {
public:
BufferText(void);
BufferText(Edn::File &fileName);
virtual ~BufferText(void);
void Save(void);
BufferText(void);
BufferText(Edn::File &fileName);
virtual ~BufferText(void);
void Save(void);
void GetInfo(infoStatBuffer_ts &infoToUpdate);
void SetLineDisplay(uint32_t lineNumber);
void GetInfo(infoStatBuffer_ts &infoToUpdate);
void SetLineDisplay(uint32_t lineNumber);
void DrawLine(DrawerManager &drawer, bufferAnchor_ts &anchor);
void AddChar(char * UTF8data);
void cursorMove(int32_t gtkKey);
void MouseSelectFromCursorTo(int32_t width, int32_t height);
void MouseEvent(int32_t width, int32_t height);
void MouseEventDouble(void);
void MouseEventTriple(void);
void ScrollDown(void);
void ScrollUp(void);
int32_t Display(DrawerManager &drawer);
void ForceReDraw(bool allElement);
void AddChar(char * UTF8data);
void cursorMove(int32_t gtkKey);
void MouseSelectFromCursorTo(int32_t width, int32_t height);
void MouseEvent(int32_t width, int32_t height);
void MouseEventDouble(void);
void MouseEventTriple(void);
void ScrollDown(void);
void ScrollUp(void);
void Copy(int8_t clipboardID);
void Cut(int8_t clipboardID);
void Paste(int8_t clipboardID);
void Copy(int8_t clipboardID);
void Cut(int8_t clipboardID);
void Paste(int8_t clipboardID);
void Search(Edn::String &data, bool back, bool caseSensitive, bool wrap, bool regExp);
void Replace(Edn::String &data);
int32_t FindLine(Edn::String &data);
void JumpAtLine(int32_t newLine);
int32_t GetCurrentLine(void);
void Search(Edn::String &data, bool back, bool caseSensitive, bool wrap, bool regExp);
void Replace(Edn::String &data);
int32_t FindLine(Edn::String &data);
void JumpAtLine(int32_t newLine);
int32_t GetCurrentLine(void);
void RemoveLine(void);
void SelectAll(void);
void SelectNone(void);
void Undo(void);
void Redo(void);
void SetCharset(charset_te newCharset);
bool AnchorGet(int32_t anchorID, bufferAnchor_ts & anchor);
bool AnchorNext(bufferAnchor_ts & anchor);
void RemoveLine(void);
void SelectAll(void);
void SelectNone(void);
void Undo(void);
void Redo(void);
void SetCharset(charset_te newCharset);
protected:
void NameChange(void);
void NameChange(void);
private:
// Display
ColorizeManager * myColorManager; //!< for the background color :
int32_t m_nbColoneForLineNumber; //!< number of colomn use for linenumber display
bool NeedToCleanEndPage; //!< if true, the end of the page need to be clean (arrive after a remove line)
uint32_t nbColoneForLineNumber; //!< number of colome used to display the line Number
ColorizeManager * myColorManager; //!< for the background color :
// Direct buffer IO
EdnBuf m_EdnBuf; //!< buffer associated on this displayer
EdnBuf m_EdnBuf; //!< buffer associated on this displayer
position_ts m_displayStart; //!< position where the display is starting
position_ts m_displaySize; //!< number of char displayable in the screan
int32_t m_displayStartBufferPos; //!< position where the buffer start
// Cursor :
int32_t m_cursorPosPrevious; //!< Previous position in the buffer of the cursor
int32_t m_cursorPos; //!< position in the buffer of the cursor
int32_t m_cursorPreferredCol; //!< colomn of the last up and down ...
bool m_cursorOn; //!< the blink of the cursor ...
cursorDisplayMode_te m_cursorMode; //!< type of cursor Selected
int32_t m_cursorPos; //!< position in the buffer of the cursor
int32_t m_cursorPreferredCol; //!< colomn of the last up and down ...
bool m_cursorOn; //!< the blink of the cursor ...
cursorDisplayMode_te m_cursorMode; //!< type of cursor Selected
displayHLData_ts m_displayLocalSyntax; //!< for the display of the local elements (display HL mode)
// internal function
void BasicInit(void);
@@ -101,6 +103,10 @@ class BufferText : public Buffer {
void CleanSelectLine(void);
void SelectionStart(void);
void SelectionEnd(void);
void SelectionCheckMode(void);
void CheckAndUpdateLineForModification(uint32_t lineID);
bool TextDMoveUp(int32_t offset);
bool TextDMoveDown(int32_t offset);
@@ -108,9 +114,7 @@ class BufferText : public Buffer {
void GetMousePosition(int32_t width, int32_t height, int32_t &x, int32_t &y);
void MoveUpDown(int32_t ofset);
void DrawLineNumber(DrawerManager &drawer, int32_t lineNumber, int32_t positionY);
void UpdatePointerNumber(void);
void DrawLineNumber(DrawerManager &drawer,char *myPrint, int32_t lineNumber, int32_t positionY);
};

2
Sources/CustumWidget/BufferView/BufferView.cpp
View File

@@ -57,8 +57,6 @@ BufferView::BufferView(void) : MsgBroadcast("Buffer View", EDN_CAT_GUI)
# elif defined( USE_GTK_VERSION_2_0 )
GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
# endif
// Remove double-buffering ==> in the current case we can not get the previous display...
gtk_widget_set_double_buffered(m_widget, false);
// Focus Event
g_signal_connect( G_OBJECT(m_widget), "focus_in_event", G_CALLBACK(CB_focusGet), this);
g_signal_connect( G_OBJECT(m_widget), "focus_out_event", G_CALLBACK(CB_focusLost), this);

130
Sources/CustumWidget/CodeView/CodeView.cpp
View File

@@ -38,53 +38,46 @@
CodeView::CodeView(void) : MsgBroadcast("Code View", EDN_CAT_WORK_AREA)
{
// Init link with the buffer Manager
m_bufferManager = BufferManager::getInstance();
m_colorManager = ColorizeManager::getInstance();
static int32_t staticIntLocal = 100;
m_displayUniqueId = staticIntLocal++;
m_bufferID = -1;
m_bufferManager->Get(m_bufferID)->AnchorAdd(m_displayUniqueId);
m_buttunOneSelected = false;
m_shawableAreaX = 0;
m_shawableAreaY = 0;
// Init link with the buffer Manager
m_bufferManager = BufferManager::getInstance();
m_colorManager = ColorizeManager::getInstance();
m_widget = gtk_drawing_area_new();
gtk_widget_set_size_request( m_widget, 200, 100);
gtk_widget_add_events( m_widget,
GDK_KEY_PRESS_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
gtk_widget_add_events( m_widget,
GDK_KEY_PRESS_MASK
| GDK_BUTTON_PRESS_MASK
| GDK_BUTTON_RELEASE_MASK
| GDK_POINTER_MOTION_MASK
| GDK_POINTER_MOTION_HINT_MASK);
# ifdef USE_GTK_VERSION_3_0
g_object_set(m_widget,"can-focus", TRUE, NULL);
# elif defined( USE_GTK_VERSION_2_0 )
GTK_WIDGET_SET_FLAGS(m_widget, GTK_CAN_FOCUS);
# endif
// Remove double-buffering ==> in the current case we can not get the previous display...
gtk_widget_set_double_buffered(m_widget, false);
// Focus Event
g_signal_connect( G_OBJECT(m_widget), "focus_in_event", G_CALLBACK(CB_focusGet), this);
g_signal_connect( G_OBJECT(m_widget), "focus_out_event", G_CALLBACK(CB_focusLost), this);
g_signal_connect( G_OBJECT(m_widget), "focus_in_event", G_CALLBACK(CB_focusGet), this);
g_signal_connect( G_OBJECT(m_widget), "focus_out_event", G_CALLBACK(CB_focusLost), this);
// Keyboard Event
g_signal_connect_after( G_OBJECT(m_widget), "key_press_event", G_CALLBACK(CB_keyboardEvent), this);
g_signal_connect_after( G_OBJECT(m_widget), "key_release_event", G_CALLBACK(CB_keyboardEvent), this);
g_signal_connect_after( G_OBJECT(m_widget), "key_press_event", G_CALLBACK(CB_keyboardEvent), this);
g_signal_connect_after( G_OBJECT(m_widget), "key_release_event", G_CALLBACK(CB_keyboardEvent), this);
// Mouse Event
g_signal_connect( G_OBJECT(m_widget), "button_press_event", G_CALLBACK(CB_mouseButtonEvent), this);
g_signal_connect( G_OBJECT(m_widget), "button_release_event", G_CALLBACK(CB_mouseButtonEvent), this);
g_signal_connect( G_OBJECT(m_widget), "motion_notify_event", G_CALLBACK(CB_mouseMotionEvent), this);
g_signal_connect( G_OBJECT(m_widget), "scroll-event", G_CALLBACK(CB_mouseScrollEvent), this);
g_signal_connect( G_OBJECT(m_widget), "button_press_event", G_CALLBACK(CB_mouseButtonEvent), this);
g_signal_connect( G_OBJECT(m_widget), "button_release_event", G_CALLBACK(CB_mouseButtonEvent), this);
g_signal_connect( G_OBJECT(m_widget), "motion_notify_event", G_CALLBACK(CB_mouseMotionEvent), this);
g_signal_connect( G_OBJECT(m_widget), "scroll-event", G_CALLBACK(CB_mouseScrollEvent), this);
// Display Event
g_signal_connect( G_OBJECT(m_widget), "realize", G_CALLBACK(CB_displayInit), this);
g_signal_connect( G_OBJECT(m_widget), "realize", G_CALLBACK(CB_displayInit), this);
# ifdef USE_GTK_VERSION_3_0
g_signal_connect( G_OBJECT(m_widget), "draw", G_CALLBACK(CB_displayDraw), this);
g_signal_connect( G_OBJECT(m_widget), "draw", G_CALLBACK(CB_displayDraw), this);
# elif defined( USE_GTK_VERSION_2_0 )
g_signal_connect( G_OBJECT(m_widget), "expose_event", G_CALLBACK(CB_displayDraw), this);
g_signal_connect( G_OBJECT(m_widget), "expose_event", G_CALLBACK(CB_displayDraw), this);
# endif
}
@@ -105,9 +98,8 @@ void CodeView::OnMessage(int32_t id, int32_t dataID)
{
case EDN_MSG__CURRENT_CHANGE_BUFFER_ID:
//EDN_INFO("Select a new Buffer ... " << dataID);
m_bufferManager->Get(m_bufferID)->AnchorRm(m_displayUniqueId);
m_bufferID = dataID;
m_bufferManager->Get(m_bufferID)->AnchorAdd(m_displayUniqueId);
m_bufferManager->Get(m_bufferID)->ForceReDraw(true);
// request the dispplay of the curent Editor
SendMessage(EDN_MSG__BUFFER_CHANGE_CURRENT, m_bufferID);
break;
@@ -192,11 +184,11 @@ void CodeView::OnMessage(int32_t id, int32_t dataID)
break;
}
// Force redraw of the widget
gtk_widget_queue_draw_area(m_widget, 0, 0, m_shawableAreaX, m_shawableAreaY);
gtk_widget_queue_draw(m_widget);
}
gboolean CodeView::CB_displayDraw( GtkWidget *widget, GdkEventExpose *event, gpointer data)
{
CodeView * self = reinterpret_cast<CodeView*>(data);
@@ -205,7 +197,6 @@ gboolean CodeView::CB_displayDraw( GtkWidget *widget, GdkEventExpose *event, gpo
# ifdef USE_GTK_VERSION_3_0
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
EDN_INFO("GTK+ request a diplay of : "<< allocation.width <<"px * "<< allocation.height <<"px");
bool needRedrawAll = false;
if (self->m_shawableAreaX != allocation.width) {
needRedrawAll = true;
@@ -216,7 +207,6 @@ gboolean CodeView::CB_displayDraw( GtkWidget *widget, GdkEventExpose *event, gpo
self->m_shawableAreaY = allocation.height;
}
# elif defined( USE_GTK_VERSION_2_0)
EDN_INFO("GTK+ request a diplay of : "<< widget->allocation.width <<"px * "<< widget->allocation.height <<"px");
bool needRedrawAll = false;
if (self->m_shawableAreaX != widget->allocation.width) {
needRedrawAll = true;
@@ -227,51 +217,32 @@ gboolean CodeView::CB_displayDraw( GtkWidget *widget, GdkEventExpose *event, gpo
self->m_shawableAreaY = widget->allocation.height;
}
# endif
EDN_INFO("Edn request a display of : " << self->m_shawableAreaX << "px * "<< self->m_shawableAreaY<<"px");
if (true == needRedrawAll) {
//updateScrollElement();
self->m_bufferManager->Get(self->m_bufferID)->ForceReDraw(true);
}
EDN_INFO("Request a display of : " << self->m_shawableAreaX << "px * "<< self->m_shawableAreaY<<"px");
/*
EDN_INFO("widget width=%d", widget->allocation.width);
EDN_INFO("widget height=%d", widget->allocation.height);
*/
//EDN_INFO("BufferView Display");
// Get the color Manager :
ColorizeManager *myColorManager = NULL;
myColorManager = ColorizeManager::getInstance();
Buffer * tmpBuf = self->m_bufferManager->Get(self->m_bufferID);
#ifndef NDEBUG
GTimeVal timeStart;
g_get_current_time(&timeStart);
#endif
bufferAnchor_ts anchor;
tmpBuf->AnchorSetSize(self->m_displayUniqueId, self->m_shawableAreaX, self->m_shawableAreaY);
bool enableToWrite = tmpBuf->AnchorGet(self->m_displayUniqueId, anchor);
DrawerManager monDrawer(widget, self->m_shawableAreaX, self->m_shawableAreaY, Display::GetFontHeight()*anchor.m_BufferNumberLineOffset);
int32_t currentLineID = 0;
while (true == enableToWrite) {
if (true == anchor.m_redrawLine[currentLineID]) {
#ifndef NDEBUG
EDN_DEBUG("draw line=" << currentLineID << " realID=" << anchor.m_lineNumber );
#endif
tmpBuf->DrawLine(monDrawer, anchor);
}
enableToWrite = tmpBuf->AnchorNext(anchor);
currentLineID++;
}
monDrawer.Flush();
// Need to clean the end of windows (sometimes)...
if(currentLineID<anchor.m_displaySize.y+1) {
for (int32_t iii=currentLineID; iii < anchor.m_displaySize.y; iii++) {
tmpBuf->DrawLineEmpty(monDrawer, iii);
}
}
#ifndef NDEBUG
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_DEBUG("Display Generation = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s ==> " << (timeStop.tv_usec - timeStart.tv_usec)/1000. << "ms");
#endif
//(void)m_bufferManager->Get(m_bufferID)->Display(m_displayParameters, m_shawableAreaX, m_shawableAreaY);
DrawerManager monDrawer(widget, self->m_shawableAreaX, self->m_shawableAreaY);
//EDN_INFO("Display buffer ID = " << m_bufferID);
(void)self->m_bufferManager->Get(self->m_bufferID)->Display(monDrawer);
// EDN_WARNING("Must display here ... ");
return TRUE;
}
// sur : émis lors du premier affichage de la GtkDrawingArea
gboolean CodeView::CB_displayInit( GtkWidget *widget, gpointer data)
{
@@ -279,15 +250,22 @@ gboolean CodeView::CB_displayInit( GtkWidget *widget, gpointer data)
# ifdef USE_GTK_VERSION_3_0
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
EDN_INFO("GTK+ request a diplay of : "<< allocation.width <<"px * "<< allocation.height <<"px");
int32_t size_x = allocation.width;
int32_t size_y = allocation.height;
self->m_shawableAreaX = allocation.width;
self->m_shawableAreaY = allocation.height;
# elif defined( USE_GTK_VERSION_2_0)
EDN_INFO("GTK+ request a diplay of : "<< widget->allocation.width <<"px * "<< widget->allocation.height <<"px");
int32_t size_x = widget->allocation.width;
int32_t size_y = widget->allocation.height;
self->m_shawableAreaX = widget->allocation.width;
self->m_shawableAreaY = widget->allocation.height;
# endif
EDN_INFO("Request a diplay of : "<< size_x <<"px * "<< size_y <<"px");
gtk_widget_queue_draw( widget );
return TRUE;
}
@@ -298,12 +276,6 @@ gint CodeView::CB_focusGet( GtkWidget *widget, GdkEventFocus *event, gpointer da
GTK_WIDGET_SET_FLAGS (widget, GTK_HAS_FOCUS);
# endif
self->SendMessage(EDN_MSG__BUFFER_CHANGE_CURRENT, self->m_bufferID);
# ifdef USE_GTK_VERSION_2_0
Buffer * tmpBuf = self->m_bufferManager->Get(self->m_bufferID);
tmpBuf->AnchorRedrawAll(self->m_displayUniqueId);
// Force redraw of the widget
gtk_widget_queue_draw_area(self->m_widget, 0, 0, self->m_shawableAreaX, self->m_shawableAreaY);
# endif
EDN_INFO("Focus - In");
return FALSE;
}

4
Sources/CustumWidget/CodeView/CodeView.h
View File

@@ -54,10 +54,6 @@ class CodeView : public MsgBroadcast
private:
// main windows widget :
GtkWidget * m_widget;
DrawerManager * m_Drawer;
int32_t m_displayUniqueId;
//position_ts m_displayStart; //!< position where the display is starting
//position_ts m_displaySize; //!< number of char displayable in the screan
// récupération des proprieter général...
BufferManager * m_bufferManager;
ColorizeManager * m_colorManager;

3
Sources/GuiTools/MainWindows/MainWindows.cpp
View File

@@ -165,11 +165,8 @@ void MainWindows::SetTitle(Edn::File &fileName, bool isModify)
}
tmp += "Edn";
gtk_window_set_title(GTK_WINDOW(m_mainWindow), tmp.c_str());
tmp = " ";
if (fileName.GetShortFilename() != "") {
tmp = fileName.GetFolder();
tmp += "/";
tmp += fileName.GetShortFilename();
} else {
tmp = "Edn";
}

66
Sources/tools/Display/Display.cpp
View File

@@ -40,7 +40,7 @@
#define FONT_ITALIC_YES (1)
// Variables priv<EFBFBD> du namespace
// Variables privé du namespace
#define POLICE_NAME "Monospace"
#ifdef USE_GTK_VERSION_3_0
@@ -127,7 +127,6 @@ cairo_font_face_t * Display::GetFont(bool bold, bool italic)
#undef __class__
#define __class__ "DrawerManager"
//#define megaplop mlkjmlk
/**
* @brief DrawerManager constructor : generate a memoryDC where we can draw everything...
*
@@ -140,48 +139,25 @@ cairo_font_face_t * Display::GetFont(bool bold, bool italic)
* @return ---
*
*/
DrawerManager::DrawerManager(GtkWidget * widget, int32_t x, int32_t y, int32_t scrollOffset)
DrawerManager::DrawerManager(GtkWidget * widget, int32_t x, int32_t y)
{
m_size.x = x;
m_size.y = y;
m_haveWork = false;
// Create the Cairo Element
# if USE_GTK_VERSION_3_0
m_windows = gtk_widget_get_window(widget);
m_cairo = gdk_cairo_create(gtk_widget_get_window(widget));
# elif USE_GTK_VERSION_2_0
m_windows = widget->window;
m_cairo = gdk_cairo_create(widget->window);
# endif
// Double buffer with previous copy management :
{
// Create the Cairo context from the current windows
cairo_t * cairoWindows = gdk_cairo_create(m_windows);
// inform that we nee a double buffer
GdkRectangle myRect = {0, 0, x, y};
gdk_window_begin_paint_rect(m_windows, &myRect);
// Create the Cairo context from the double Buffer just created
m_cairo = gdk_cairo_create(m_windows);
// Copy the previous display data from the current display to the double buffer area:
cairo_surface_t * drawableSurface = cairo_get_target(cairoWindows);
TranslateVertical(-1* scrollOffset);
cairo_set_source_surface(m_cairo, drawableSurface, 0, 0);
cairo_paint(m_cairo);
TranslateVertical(scrollOffset);
//cairo_surface_destroy(drawableSurface);
cairo_destroy(cairoWindows);
}
cairo_scale(m_cairo, 1.0, 1.0);
# ifndef NDEBUG
// for Test only : this remove slowly the old line that is not rewritten
cairo_set_source_rgb(m_cairo, 0, 0, 0);
cairo_set_source_rgba(m_cairo, 1, 1, 1, 0.05);
cairo_paint(m_cairo);
# endif
//cairo_translate(m_cairo, 0, 7);
cairo_set_source_rgb(m_cairo, 0, 0, 0);
cairo_paint(m_cairo);
cairo_set_font_size(m_cairo, POLICE_SIZE);
m_dataToDisplay[0] = '\0';
m_nbElement = 0;
cairo_scale(m_cairo, 1.0, 1.0);
// http://cairographics.org/FAQ/#clear_a_surface
// http://gtk.developpez.com/faq/?page=gtkwidget#GTK_WIDGET_transparent
@@ -190,6 +166,10 @@ DrawerManager::DrawerManager(GtkWidget * widget, int32_t x, int32_t y, int32_t s
//cairo_paint(m_cairo);
//cairo_fill(m_cairo);
//cairo_stroke (m_cairo);
}
@@ -205,9 +185,6 @@ DrawerManager::DrawerManager(GtkWidget * widget, int32_t x, int32_t y, int32_t s
*/
DrawerManager::~DrawerManager()
{
// call the painting of the double buffer in the displayed current buffer
gdk_window_end_paint(m_windows);
// Destroy cairo context
cairo_destroy(m_cairo);
}
@@ -312,8 +289,9 @@ void DrawerManager::Flush(void)
int32_t letterHeight = Display::GetFontHeight();
if (true == m_selectColor->HaveBg() ) {
int32_t letterWidth = Display::GetFontWidth();
int32_t stringLen = m_nbElement;
// generate Clean BG:
DirectRectangle(m_selectColor, m_pos.x, m_pos.y, letterWidth*m_nbElement, letterHeight);
DirectRectangle(m_selectColor, m_pos.x, m_pos.y, letterWidth*stringLen, letterHeight);
}
cairo_move_to(m_cairo, m_pos.x, m_pos.y+letterHeight-4);
m_selectColor->ApplyFG(m_cairo);
@@ -372,10 +350,9 @@ void DrawerManager::DirectRectangle(Colorize *SelectColor, int32_t x, int32_t y,
// flush
cairo_fill(m_cairo);
}
void DrawerManager::DirectRectangle(color_ts &SelectColor, int32_t x, int32_t y, int32_t width, int32_t height)
{
cairo_set_source_rgb(m_cairo, SelectColor.red, SelectColor.green, SelectColor.blue);
// set postion
cairo_rectangle(m_cairo, x, y, width, height);
@@ -453,7 +430,6 @@ void DrawerManager::Cursor(int32_t x, int32_t y)
cairo_rel_line_to(m_cairo, 0, -letterHeight);
}
cairo_stroke(m_cairo);
//cairo_set_fill_rule(m_cairo, CAIRO_FILL_RULE_EVEN_ODD);
cairo_fill(m_cairo);
}
@@ -601,14 +577,6 @@ void DrawerManager::UTF8UnknownElement(Colorize *SelectColor, int32_t x, int32_t
}
void DrawerManager::TranslateVertical(int32_t nbPixelTranslation)
{
Flush();
//scale((xmax-xmin)/W, (ymax-ymin)/H)
cairo_translate(m_cairo, 0, nbPixelTranslation);
cairo_fill(m_cairo);
cairo_paint(m_cairo);
}
/* Basic axample with cairo and pango...

5
Sources/tools/Display/Display.h
View File

@@ -52,7 +52,7 @@ class DrawerManager;
class DrawerManager {
public:
// Constructeur
DrawerManager(GtkWidget * widget, int32_t x, int32_t y, int32_t scrollOffset=0);
DrawerManager(GtkWidget * widget, int32_t x, int32_t y);
~DrawerManager();
void Rectangle(Colorize *SelectColor, int32_t x, int32_t y, int32_t width, int32_t height);
@@ -72,7 +72,6 @@ class DrawerManager {
void Flush(void);
int32_t GetWidth(void) { return m_size.x; };
int32_t GetHeight(void) { return m_size.y; };
void TranslateVertical(int32_t nbPixelTranslation);
private:
void DirectRectangle(Colorize *SelectColor, int32_t x, int32_t y, int32_t width, int32_t height);
@@ -86,7 +85,7 @@ class DrawerManager {
position_ts m_size; //!< Total size
cairo_t * m_cairo; //!< Cairo Layout pointer
GdkWindow * m_windows; //!< remember the current widget ==> for some internal problems
};

107
Sources/tools/EdnBuf/EdnBuf.cpp
View File

@@ -646,22 +646,8 @@ int32_t EdnBuf::CountLines(int32_t startPos, int32_t endPos)
EdnVectorBuf::Iterator myPosIt = m_data.Position(startPos);
int32_t lineCount = 0;
#ifndef NDEBUG
GTimeVal timeStart;
if (0 == startPos) {
g_get_current_time(&timeStart);
}
#endif
while (myPosIt) {
if (myPosIt.Position() == endPos) {
#ifndef NDEBUG
if (0 == startPos) {
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_ERROR("Count line (" << startPos << "," << endPos << ") time = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s ==> " << (timeStop.tv_usec - timeStart.tv_usec)/1000. << "ms");
}
#endif
return lineCount;
}
if ('\n' == *myPosIt) {
@@ -669,76 +655,6 @@ int32_t EdnBuf::CountLines(int32_t startPos, int32_t endPos)
}
myPosIt++;
}
#ifndef NDEBUG
if (0 == startPos) {
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_ERROR("Count line (" << startPos << "," << endPos << ") time = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s ==> " << (timeStop.tv_usec - timeStart.tv_usec)/1000. << "ms");
}
#endif
return lineCount;
}
/**
* @brief Get the Id of the line where is positionned the current pos element
*
* @param[in] pos posithion in the buffer where we need to know the current line
* @param[in] refPos reference position
* @param[in] refLine reference Line of the position
*
* @return the current line ID of the pos
*
*/
int32_t EdnBuf::GetLinesIdWithRef(int32_t pos, int32_t refPos, int32_t refLine)
{
EdnVectorBuf::Iterator myPosIt = m_data.Position(refPos);
int32_t lineCount = refLine;
#ifndef NDEBUG
GTimeVal timeStart;
g_get_current_time(&timeStart);
#endif
if (pos == refPos) {
return refLine;
} else if (pos > refPos) {
while (myPosIt) {
if (myPosIt.Position() == pos) {
#ifndef NDEBUG
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_DEBUG("Count line " << pos << " with ref(" << refPos << "," << refPos << ") time = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s ==> " << (timeStop.tv_usec - timeStart.tv_usec)/1000. << "ms");
#endif
return lineCount;
}
if ('\n' == *myPosIt) {
lineCount++;
}
myPosIt++;
}
} else {
while (myPosIt) {
if (myPosIt.Position() == pos) {
#ifndef NDEBUG
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_DEBUG("Count line " << pos << " with ref(" << refPos << "," << refPos << ") time = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s ==> " << (timeStop.tv_usec - timeStart.tv_usec)/1000. << "ms");
#endif
return lineCount;
}
if ('\n' == *myPosIt) {
lineCount--;
}
myPosIt--;
}
}
#ifndef NDEBUG
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_DEBUG("Count line " << pos << " with ref(" << refPos << "," << refPos << ") time = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s ==> " << (timeStop.tv_usec - timeStart.tv_usec)/1000. << "ms");
#endif
return lineCount;
}
@@ -769,21 +685,12 @@ int32_t EdnBuf::CountLines(void)
EdnVectorBuf::Iterator myPosIt = m_data.Begin();
int32_t lineCount = 0;
#ifndef NDEBUG
GTimeVal timeStart;
g_get_current_time(&timeStart);
#endif
while(myPosIt) {
if ('\n' == *myPosIt) {
lineCount++;
}
myPosIt++;
}
#ifndef NDEBUG
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_DEBUG("count total number of line time = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s ==> " << (timeStop.tv_usec - timeStart.tv_usec)/1000. << "ms");
#endif
return lineCount;
}
@@ -813,12 +720,6 @@ void EdnBuf::CountNumberOfLines(void)
*/
int32_t EdnBuf::CountForwardNLines(int32_t startPos, int32_t nLines)
{
#ifndef NDEBUG
GTimeVal timeStart;
if (0 == startPos) {
g_get_current_time(&timeStart);
}
#endif
if (nLines == 0) {
return startPos;
} else if (startPos > m_data.Size() ) {
@@ -838,14 +739,6 @@ int32_t EdnBuf::CountForwardNLines(int32_t startPos, int32_t nLines)
}
myPosIt++;
}
#ifndef NDEBUG
if (0 == startPos) {
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_DEBUG("get poiner line (pos=" << startPos << "=>" << nLines << "lines) time = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s ==> " << (timeStop.tv_usec - timeStart.tv_usec)/1000. << "ms");
}
#endif
//EDN_INFO(" ==> (2) at position=" << myPosIt.Position() );
return myPosIt.Position();
}

4
Sources/tools/EdnBuf/EdnBuf.h
View File

@@ -105,7 +105,6 @@ class EdnBuf {
int32_t CharWidth( char c, int32_t indent); // TODO : rework this
int32_t CountDispChars( int32_t lineStartPos, int32_t targetPos);
int32_t CountForwardDispChars( int32_t lineStartPos, int32_t nChars);
int32_t GetLinesIdWithRef( int32_t pos, int32_t refPos, int32_t refLine);
int32_t CountLines( int32_t startPos, int32_t endPos);
int32_t CountLines( void);
int32_t CountLines( Edn::VectorType<int8_t> &data);
@@ -165,8 +164,7 @@ class EdnBuf {
void FindMainHighLightPosition(int32_t startPos, int32_t endPos, int32_t &startId, int32_t &stopId, bool backPreviousNotEnded);
public:
void SetHLSystem( Highlight * newHLSystem);
void HightlightOneLine(displayHLData_ts & MData, int32_t HLStart, int32_t HLStop);
void HightlightGenerateLines(displayHLData_ts & MData, int32_t startPos, int32_t nbLines); // TODO : deprecated ...
void HightlightGenerateLines(displayHLData_ts & MData, int32_t startPos, int32_t nbLines);
colorInformation_ts * GetElementColorAtPosition(displayHLData_ts & MData, int32_t pos);
private:
colorInformation_ts * GetElementColorAtPosition(int32_t pos, int32_t &starPos);

66
Sources/tools/EdnBuf/EdnBuf_HighLight.cpp
View File

@@ -286,71 +286,6 @@ colorInformation_ts *EdnBuf::GetElementColorAtPosition(int32_t pos, int32_t &sta
return NULL;
}
//#define COUNT_TIME plop
void EdnBuf::HightlightOneLine(displayHLData_ts & MData, int32_t HLStart, int32_t HLStop)
{
MData.posHLPass1 = 0;
MData.posHLPass2 = 0;
if (NULL == m_Highlight) {
return;
}
#ifdef COUNT_TIME
GTimeVal timeStart;
g_get_current_time(&timeStart);
#endif
int32_t startId, stopId;
// find element previous
FindMainHighLightPosition(HLStart, HLStop, startId, stopId, true);
int32_t k;
//EDN_DEBUG("List of section between : "<< startId << " & " << stopId);
int32_t endSearch = stopId+1;
if (-1 == stopId) {
endSearch = m_HLDataPass1.Size();
}
for (k=edn_max(startId, 0); k<endSearch; k++) {
// empty section :
if (0==k) {
if (HLStart < m_HLDataPass1[k].beginStart) {
//EDN_DEBUG(" ==> (empty section 1 ) k="<<k<<" start="<<HLStart<<" stop="<<m_HLDataPass1[k].beginStart );
m_Highlight->Parse2(HLStart,
m_HLDataPass1[k].beginStart,
MData.HLData,
m_data);
} // else : nothing to do ...
} else {
//EDN_DEBUG(" ==> (empty section 2 ) k="<<k<<" start="<<m_HLDataPass1[k-1].endStop<<" stop="<<m_HLDataPass1[k].beginStart );
m_Highlight->Parse2(m_HLDataPass1[k-1].endStop,
m_HLDataPass1[k].beginStart,
MData.HLData,
m_data);
}
// under section :
//EDN_DEBUG(" ==> (under section ) k="<<k<<" start="<<m_HLDataPass1[k].beginStart<<" stop="<<m_HLDataPass1[k].endStop << " subSectionOfID=" << 99999999);
// TODO : ...
}
if (endSearch == (int32_t)m_HLDataPass1.Size() ){
if (m_HLDataPass1.Size() != 0) {
//EDN_DEBUG(" ==> (empty section 3 ) k="<<k<<" start="<<m_HLDataPass1[k-1].endStop<<" stop="<<HLStop );
m_Highlight->Parse2(m_HLDataPass1[k-1].endStop,
HLStop,
MData.HLData,
m_data);
} else {
//EDN_DEBUG(" ==> (empty section 4 ) k="<<k<<" start=0 stop="<<HLStop );
m_Highlight->Parse2(0,
HLStop,
MData.HLData,
m_data);
}
}
#ifdef COUNT_TIME
GTimeVal timeStop;
g_get_current_time(&timeStop);
EDN_DEBUG("Display reAnnalyse = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s");
#endif
}
void EdnBuf::HightlightGenerateLines(displayHLData_ts & MData, int32_t HLStart, int32_t nbLines)
@@ -419,6 +354,7 @@ void EdnBuf::HightlightGenerateLines(displayHLData_ts & MData, int32_t HLStart,
g_get_current_time(&timeStop);
EDN_DEBUG("Display reAnnalyse = " << timeStop.tv_usec - timeStart.tv_usec << " micro-s");
}
}

8
Sources/tools/charset/charset.cpp
View File

@@ -422,11 +422,7 @@ static uint32_t Utf8_GetValue(UTF8Element_ts &Element)
int32_t strUtf8Len(const char *input_UTF8)
{
int32_t count = 0;
int32_t sizeInput = strlen(input_UTF8);
int32_t size = sizeInput;
if (size>20) {
EDN_DEBUG("check SIZE...");
}
int32_t size = strlen(input_UTF8);
uint8_t tmpSize;
bool baseValid;
while (size > 0) {
@@ -1147,7 +1143,7 @@ void ConvertInput(GdkEventKey *event, char* Utf8Out, bool &controlKey, bool &mov
case GDK_KEY_Caps_Lock:
# elif USE_GTK_VERSION_2_0
case GDK_Caps_Lock:
# endif
# endif
controlKey = true;
break;
default:

3
avancement.boo
View File

@@ -1,7 +1,7 @@
# action a faire (ordonner par r<>vision) :
* 0.2.X :
- gui : Amelioration du full-screen et du display de base (sans l'entete de la fenetre)
- gui : display partielle de la fenetre
- gui : Mise en place d'un display ligne par ligne
- gui : ascenceur quand n<>cessaire
- gui : Demander la cr<63>ation de nouveaux fichier quand il n'existe pas (a l'ouverture en ligne de commande)
- sys : Mise en place des colorisation de base pour le
@@ -10,6 +10,7 @@
- sys : replace TAB with space when Tab is pressed
- sys : Catch F[1-12] ==> for user personal event
- BUG : Correction du bug des entr<74> bizard tel que les chapot et les guillemets
- BUG : de s<>lection quand la ligne est pleine et la premi<6D>re ligne s<>ctionn<6E>e. ==> regarder apr<70>s avoir fait le display ligne par ligne...
- BUG : de copier coller sur les <20><><EFBFBD> ...
- BUG : les caract<63>re multiples type chapot ...
- BUG : italique non g<>n<EFBFBD>r<EFBFBD>

57
test_transparence.c
View File

@@ -20,7 +20,7 @@ static gboolean expose(GtkWidget *widget, GdkEventExpose *event, gpointer user_d
static void clicked(GtkWindow *win, GdkEventButton *event, gpointer user_data);
#if USE_GTK_VERSION_3_0
# if USE_GTK_VERSION_3_0
const GdkRGBA color = { 1.0, 1.0, 0.0, 0.0};
#endif
@@ -36,9 +36,6 @@ int main(int argc, char **argv)
gtk_widget_set_app_paintable(window, TRUE);
// Remove double-buffering ==> in the current case we can not get the previous display...
gtk_widget_set_double_buffered(window, FALSE);
# if USE_GTK_VERSION_3_0
g_signal_connect(G_OBJECT(window), "draw", G_CALLBACK(expose), NULL);
# elif USE_GTK_VERSION_2_0
@@ -63,17 +60,17 @@ int main(int argc, char **argv)
&color);
*/
#endif
//gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
//gtk_widget_add_events(window, GDK_BUTTON_PRESS_MASK);
/* //g_signal_connect(G_OBJECT(window), "button-press-event", G_CALLBACK(clicked), NULL);
gtk_window_set_decorated(GTK_WINDOW(window), FALSE);
gtk_widget_add_events(window, GDK_BUTTON_PRESS_MASK);
g_signal_connect(G_OBJECT(window), "button-press-event", G_CALLBACK(clicked), NULL);
GtkWidget* fixed_container = gtk_fixed_new();
gtk_container_add(GTK_CONTAINER(window), fixed_container);
GtkWidget* button = gtk_button_new_with_label("button1");
gtk_widget_set_size_request(button, 100, 100);
gtk_container_add(GTK_CONTAINER(fixed_container), button);
*/
//screen_changed(window, NULL, NULL);
screen_changed(window, NULL, NULL);
gtk_widget_show_all(window);
gtk_main();
@@ -117,36 +114,20 @@ static void screen_changed(GtkWidget *widget, GdkScreen *old_screen, gpointer us
static gboolean expose(GtkWidget *widget, GdkEventExpose *event, gpointer userdata)
{
return FALSE;
# if USE_GTK_VERSION_3_0
cairo_t *cr = gdk_cairo_create(gtk_widget_get_window(widget));
# elif USE_GTK_VERSION_2_0
cairo_t *cr = gdk_cairo_create(widget->window);
# endif
if (TRUE == supports_alpha)
cairo_set_source_rgba (cr, 0.0, 0.0, 1.0, 0.3); /* transparent */
else
cairo_set_source_rgb (cr, 1.0, 0.0, 0.0); /* opaque white */
//return FALSE;
GdkWindow * m_windows = NULL;
# if USE_GTK_VERSION_3_0
m_windows = gtk_widget_get_window(widget);
# elif USE_GTK_VERSION_2_0
m_windows = widget->window;
# endif
gtk_widget_shape_combine_mask(widget, NULL, 0, 0);
cairo_t *cr = gdk_cairo_create(m_windows);
//if (TRUE == supports_alpha) {
cairo_set_source_rgba (cr, 0.0, 0.0, 1.0, 0.2); // transparent
/*} else {
cairo_set_source_rgb (cr, 1.0, 0.0, 0.0); // opaque white
}*/
/* draw the background */
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
/* draw a circle */
int width, height;
gtk_window_get_size(GTK_WINDOW(widget), &width, &height);
cairo_set_source_rgba(cr, 1, 0.2, 0.2, 0.6);
cairo_arc(cr, width / 2, height / 2, (width < height ? width : height) / 2 - 8 , 0, 2 * 3.14);
cairo_fill(cr);
cairo_stroke(cr);
/* draw the background */
cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
cairo_paint (cr);
cairo_destroy(cr);

292
test_transparence2.c
View File

@@ -1,292 +0,0 @@
/*******************************************************************************
**3456789 123456789 123456789 123456789 123456789 123456789 123456789 123456789
** 10 20 30 40 50 60 70 80
**
** program:
** input_shape_test
**
** created:
** 19.2.2006
**
** last change:
** 20.2.2006
**
** author:
** Mirco "MacSlow" Mueller <macslow@bangang.de>
**
** license:
** GPL
**
** notes:
** - this is a test I did to figure out how to use input-shapes (XShape 1.1)
** - opens a decoration-less and transparent gtk+-window and draws a red
** cross with a circle around it
** - only the parts drawn will be "draggable"
** - window can be dragged around with LMB-drag
** - window can be resized with MMB-drag (the input-shape also resizes!)
** - window can be exited with ESC or q
** - needs a compositing manager to run in order to look as intended
** - tested with xcompmgr and compiz
** - tested with gtk+-2.8.11 and gtk+-2.9.0 (CVS-head)
**
** bugs:
** - there are no size-checks done for the input-shape, so I don't know what
** will happen, if you make the window super large
**
** todo:
** - nothing
**
** compile with:
** gcc `pkg-config --cflags --libs gtk+-2.0` input_shape_test.c -o input_shape_test
**
*******************************************************************************/
#include <math.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtk.h>
#if !GTK_CHECK_VERSION(2,9,0)
#include <X11/Xlib.h>
#include <X11/extensions/shape.h>
#include <gdk/gdkx.h>
#endif
#define WIN_WIDTH 300
#define WIN_HEIGHT 300
gint g_iCurrentWidth = WIN_WIDTH;
gint g_iCurrentHeight = WIN_HEIGHT;
void update_input_shape (GtkWidget* pWindow, int iWidth, int iHeight);
void on_alpha_screen_changed (GtkWidget* pWidget, GdkScreen* pOldScreen, GtkWidget* pLabel);
void render (cairo_t* pCairoContext, gint iWidth, gint iHeight);
gboolean on_expose (GtkWidget* pWidget, GdkEventExpose* pExpose);
gboolean on_key_press (GtkWidget* pWidget, GdkEventKey* pKey, gpointer userData);
gboolean on_button_press (GtkWidget* pWidget, GdkEventButton* pButton, GdkWindowEdge edge);
gboolean on_configure (GtkWidget* pWidget, GdkEventConfigure* pEvent, gpointer data);
#if !GTK_CHECK_VERSION(2,9,0)
void do_shape_combine_mask (GdkWindow* window, GdkBitmap* mask, gint x, gint y);
#endif
void update_input_shape (GtkWidget* pWindow, int iWidth, int iHeight);
void on_alpha_screen_changed (GtkWidget* pWidget,
GdkScreen* pOldScreen,
GtkWidget* pLabel)
{
GdkScreen* pScreen = gtk_widget_get_screen (pWidget);
GdkColormap* pColormap = gdk_screen_get_rgba_colormap (pScreen);
if (!pColormap)
pColormap = gdk_screen_get_rgb_colormap (pScreen);
gtk_widget_set_colormap (pWidget, pColormap);
}
void render (cairo_t* pCairoContext, gint iWidth, gint iHeight)
{
cairo_scale (pCairoContext, (double) iWidth, (double) iHeight);
cairo_set_source_rgba (pCairoContext, 1.0f, 1.0f, 1.0f, 0.0f);
cairo_set_operator (pCairoContext, CAIRO_OPERATOR_SOURCE);
cairo_paint (pCairoContext);
cairo_set_source_rgba (pCairoContext, 1.0f, 0.0f, 0.0f, 0.75f);
cairo_set_line_width (pCairoContext, 0.1f);
cairo_move_to (pCairoContext, 0.15f, 0.15f);
cairo_line_to (pCairoContext, 0.85f, 0.85f);
cairo_move_to (pCairoContext, 0.85f, 0.15f);
cairo_line_to (pCairoContext, 0.15f, 0.85f);
cairo_stroke (pCairoContext);
cairo_arc (pCairoContext, 0.5f, 0.5f, 0.45f, 0.0f, M_PI/180.0f * 360.0f);
cairo_stroke (pCairoContext);
}
gboolean on_expose (GtkWidget* pWidget,
GdkEventExpose* pExpose)
{
gint iWidth;
gint iHeight;
cairo_t* pCairoContext = NULL;
pCairoContext = gdk_cairo_create (pWidget->window);
if (!pCairoContext)
return FALSE;
gtk_window_get_size (GTK_WINDOW (pWidget), &iWidth, &iHeight);
render (pCairoContext, iWidth, iHeight);
cairo_destroy (pCairoContext);
return FALSE;
}
gboolean on_configure (GtkWidget* pWidget,
GdkEventConfigure* pEvent,
gpointer userData)
{
gint iNewWidth = pEvent->width;
gint iNewHeight = pEvent->height;
if (iNewWidth != g_iCurrentWidth || iNewHeight != g_iCurrentHeight)
{
update_input_shape (pWidget, iNewWidth, iNewHeight);
g_iCurrentWidth = iNewWidth;
g_iCurrentHeight = iNewHeight;
}
return FALSE;
}
gboolean on_key_press (GtkWidget* pWidget,
GdkEventKey* pKey,
gpointer userData)
{
gint iWidth;
gint iHeight;
if (pKey->type == GDK_KEY_PRESS)
{
switch (pKey->keyval)
{
case GDK_Escape :
case GDK_q :
gtk_main_quit ();
break;
}
}
return FALSE;
}
gboolean on_button_press (GtkWidget* pWidget,
GdkEventButton* pButton,
GdkWindowEdge edge)
{
if (pButton->type == GDK_BUTTON_PRESS)
{
if (pButton->button == 1)
gtk_window_begin_move_drag (GTK_WINDOW (gtk_widget_get_toplevel (pWidget)),
pButton->button,
pButton->x_root,
pButton->y_root,
pButton->time);
if (pButton->button == 2)
gtk_window_begin_resize_drag (GTK_WINDOW (gtk_widget_get_toplevel (pWidget)),
edge,
pButton->button,
pButton->x_root,
pButton->y_root,
pButton->time);
}
return FALSE;
}
#if !GTK_CHECK_VERSION(2,9,0)
/* this is piece by piece taken from gtk+ 2.9.0 (CVS-head with a patch applied
regarding XShape's input-masks) so people without gtk+ >= 2.9.0 can compile and
run input_shape_test.c */
void do_shape_combine_mask (GdkWindow* window,
GdkBitmap* mask,
gint x,
gint y)
{
Pixmap pixmap;
int ignore;
int maj;
int min;
if (!XShapeQueryExtension (GDK_WINDOW_XDISPLAY (window), &ignore, &ignore))
return;
if (!XShapeQueryVersion (GDK_WINDOW_XDISPLAY (window), &maj, &min))
return;
/* for shaped input we need at least XShape 1.1 */
if (maj != 1 && min < 1)
return;
if (mask)
pixmap = GDK_DRAWABLE_XID (mask);
else
{
x = 0;
y = 0;
pixmap = None;
}
XShapeCombineMask (GDK_WINDOW_XDISPLAY (window),
GDK_DRAWABLE_XID (window),
ShapeInput,
x,
y,
pixmap,
ShapeSet);
}
#endif
void update_input_shape (GtkWidget* pWindow, int iWidth, int iHeight)
{
static GdkBitmap* pShapeBitmap = NULL;
static cairo_t* pCairoContext = NULL;
pShapeBitmap = (GdkBitmap*) gdk_pixmap_new (NULL, iWidth, iHeight, 1);
if (pShapeBitmap)
{
pCairoContext = gdk_cairo_create (pShapeBitmap);
if (cairo_status (pCairoContext) == CAIRO_STATUS_SUCCESS)
{
render (pCairoContext, iWidth, iHeight);
cairo_destroy (pCairoContext);
#if !GTK_CHECK_VERSION(2,9,0)
do_shape_combine_mask (pWindow->window, NULL, 0, 0);
do_shape_combine_mask (pWindow->window, pShapeBitmap, 0, 0);
#else
gtk_widget_input_shape_combine_mask (pWindow, NULL, 0, 0);
gtk_widget_input_shape_combine_mask (pWindow, pShapeBitmap, 0, 0);
#endif
}
g_object_unref ((gpointer) pShapeBitmap);
}
}
int main (int argc, char** argv)
{
GtkWidget* pWindow = NULL;
GdkBitmap* pShapeMaskBitmap = NULL;
gtk_init (&argc, &argv);
pWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
on_alpha_screen_changed (pWindow, NULL, NULL);
gtk_widget_set_app_paintable (pWindow, TRUE);
gtk_window_set_decorated (GTK_WINDOW (pWindow), FALSE);
gtk_window_set_resizable (GTK_WINDOW (pWindow), TRUE);
gtk_window_set_title (GTK_WINDOW (pWindow), "gtk+/XShape 1.1 test");
gtk_widget_set_size_request (pWindow, g_iCurrentWidth, g_iCurrentHeight);
gtk_widget_add_events (pWindow, GDK_BUTTON_PRESS_MASK);
gtk_widget_show (pWindow);
g_signal_connect (G_OBJECT (pWindow),
"destroy",
G_CALLBACK (gtk_main_quit),
NULL);
g_signal_connect (G_OBJECT (pWindow),
"expose-event",
G_CALLBACK (on_expose),
NULL);
g_signal_connect (G_OBJECT (pWindow),
"configure-event",
G_CALLBACK (on_configure),
NULL);
g_signal_connect (G_OBJECT (pWindow),
"key-press-event",
G_CALLBACK (on_key_press),
NULL);
g_signal_connect (G_OBJECT (pWindow),
"button-press-event",
G_CALLBACK (on_button_press),
NULL);
update_input_shape (pWindow, g_iCurrentWidth, g_iCurrentHeight);
gtk_main ();
return 0;
}