Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

BTextView implementation by Marc Flerackers (with few additions of mine). Still incomplete, it works, tough.

Browse Source 
git-svn-id: file:///srv/svn/repos/haiku/trunk/current@2127 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Stefano Ceccherini 2002-12-02 20:14:03 +00:00
parent c70ca4fc3d
commit 94be8cb515
9 changed files with 2865 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

135
src/kits/interface/BTextView/LineBuffer.cpp Normal file
View File

@ -0,0 +1,135 @@
//------------------------------------------------------------------------------
// Copyright (c) 2001-2002, OpenBeOS
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File Name: LineBuffer.cpp
// Author: Marc Flerackers (mflerackers@androme.be)
// Description: Line storage used by BTextView
//------------------------------------------------------------------------------
// Standard Includes -----------------------------------------------------------
#include <string.h>
// System Includes -------------------------------------------------------------
#include "LineBuffer.h"
// Project Includes ------------------------------------------------------------
// Local Includes --------------------------------------------------------------
// Local Defines ---------------------------------------------------------------
// Globals ---------------------------------------------------------------------
//------------------------------------------------------------------------------
_BLineBuffer_::_BLineBuffer_()
: fBlockSize(20),
fItemCount(2),
fPhysicalSize(22),
fObjectList(NULL)
{
fObjectList = new STELine[fPhysicalSize];
memset(fObjectList, 0, fPhysicalSize * sizeof(STELine));
}
//------------------------------------------------------------------------------
_BLineBuffer_::~_BLineBuffer_()
{
delete[] fObjectList;
}
//------------------------------------------------------------------------------
void _BLineBuffer_::InsertLine(STELine *line, int32 index)
{
if (fItemCount == fPhysicalSize - 1)
{
STELine *new_list = new STELine[fPhysicalSize + fBlockSize];
memcpy(new_list, fObjectList, fPhysicalSize * sizeof(STELine));
delete fObjectList;
fObjectList = new_list;
fPhysicalSize += fBlockSize;
}
if (index < fItemCount)
memmove(fObjectList + index + 1, fObjectList + index,
(fItemCount - index) * sizeof(STELine));
memcpy(fObjectList + index, line, sizeof(STELine));
fItemCount++;
}
//------------------------------------------------------------------------------
void _BLineBuffer_::RemoveLines(int32 index, int32 count)
{
memmove(fObjectList + index, fObjectList + index + count,
(fItemCount - index - count) * sizeof(STELine));
fItemCount -= count;
}
//------------------------------------------------------------------------------
void _BLineBuffer_::RemoveLineRange(int32 from, int32 to)
{
int32 linefrom = OffsetToLine(from);
int32 lineto = OffsetToLine(to);
if (linefrom < lineto)
RemoveLines(linefrom + 1, lineto - linefrom);
BumpOffset(linefrom + 1, from - to);
}
//------------------------------------------------------------------------------
int32 _BLineBuffer_::OffsetToLine(int32 offset) const
{
if (offset == 0)
return 0;
for (int i = 0; i < fItemCount; i++)
{
if (offset < fObjectList[i].fOffset)
return i - 1;
}
return fItemCount - 2;
}
//------------------------------------------------------------------------------
int32 _BLineBuffer_::PixelToLine(float height) const
{
for (int i = 0; i < fItemCount; i++)
{
if (height < fObjectList[i].fHeight)
return i - 1;
}
return fItemCount - 2;
}
//------------------------------------------------------------------------------
void _BLineBuffer_::BumpOffset(int32 line, int32 offset)
{
for (int i = line; i < fItemCount; i++)
fObjectList[i].fOffset += offset;
}
//------------------------------------------------------------------------------
/*
* $Log $
*
* $Id $
*
*/

75
src/kits/interface/BTextView/LineBuffer.h Normal file
View File

@ -0,0 +1,75 @@
//------------------------------------------------------------------------------
// Copyright (c) 2001-2002, OpenBeOS
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File Name: LineBuffer.h
// Author: Marc Flerackers (mflerackers@androme.be)
// Description: Line storage used by BTextView
//------------------------------------------------------------------------------
// Standard Includes -----------------------------------------------------------
// System Includes -------------------------------------------------------------
#include "SupportDefs.h"
// Project Includes ------------------------------------------------------------
// Local Includes --------------------------------------------------------------
// Local Defines ---------------------------------------------------------------
struct STELine {
int32 fOffset;
float fHeight;
float fLineHeight;
float fWidth;
};
// Globals ---------------------------------------------------------------------
// _BLineBuffer_ class ---------------------------------------------------------
class _BLineBuffer_ {
public:
_BLineBuffer_();
virtual ~_BLineBuffer_();
void InsertLine(STELine *line, int32);
void RemoveLines(int32 index, int32 count);
void RemoveLineRange(int32 from, int32 to);
int32 OffsetToLine(int32 offset) const;
int32 PixelToLine(float height) const;
void BumpOffset(int32 line, int32 offset);
void BumpOrigin(float, int32);
int32 fBlockSize;
int32 fItemCount;
size_t fPhysicalSize;
STELine *fObjectList;
};
//------------------------------------------------------------------------------
/*
* $Log $
*
* $Id $
*
*/

156
src/kits/interface/BTextView/StyleBuffer.cpp Normal file
View File

@ -0,0 +1,156 @@
//------------------------------------------------------------------------------
// Copyright (c) 2001-2002, OpenBeOS
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File Name: StyleBuffer.cpp
// Author: Marc Flerackers (mflerackers@androme.be)
// Description: Style storage used by BTextView
//------------------------------------------------------------------------------
// Standard Includes -----------------------------------------------------------
// System Includes -------------------------------------------------------------
#include "StyleBuffer.h"
// Project Includes ------------------------------------------------------------
// Local Includes --------------------------------------------------------------
// Local Defines ---------------------------------------------------------------
// Globals ---------------------------------------------------------------------
//------------------------------------------------------------------------------
_BStyleBuffer_::_BStyleBuffer_(const BFont *font, const rgb_color *color)
: fRuns(10, 10),
fRecords(10, 10)
{
rgb_color black = {0, 0, 0, 255};
SetNullStyle(0, font ? font : be_plain_font, color ? color : &black, 0);
}
//------------------------------------------------------------------------------
_BStyleBuffer_::~_BStyleBuffer_()
{
}
//------------------------------------------------------------------------------
void _BStyleBuffer_::SetNullStyle(uint32 mode, const BFont *font,
const rgb_color *color, int32)
{
// TODO: use mode.
if (font)
fNullStyle.fFont = *font;
if (color)
fNullStyle.fColor = *color;
}
//------------------------------------------------------------------------------
void _BStyleBuffer_::GetNullStyle(const BFont **font, const rgb_color **color) const
{
*font = &fNullStyle.fFont;
*color = &fNullStyle.fColor;
}
//------------------------------------------------------------------------------
void _BStyleBuffer_::SyncNullStyle(int32)
{
}
//------------------------------------------------------------------------------
void _BStyleBuffer_::InvalidateNullStyle()
{
}
//------------------------------------------------------------------------------
bool _BStyleBuffer_::IsValidNullStyle() const
{
// TODO: why would a style be invalid?
return true;
}
//------------------------------------------------------------------------------
void _BStyleBuffer_::SetStyle(uint32 mode, const BFont *font, BFont *,
const rgb_color *color, rgb_color *) const
{
}
//------------------------------------------------------------------------------
void _BStyleBuffer_::GetStyle(uint32 mode, BFont *font, rgb_color *color) const
{
}
//------------------------------------------------------------------------------
void _BStyleBuffer_::SetStyleRange(int32 from, int32 to, int32, uint32 mode,
const BFont *, const rgb_color *)
{
}
//------------------------------------------------------------------------------
int32 _BStyleBuffer_::GetStyleRange(int32 from, int32 to) const
{
return 0;
}
//------------------------------------------------------------------------------
void _BStyleBuffer_::ContinuousGetStyle(BFont *, uint32 *, rgb_color *, bool *,
int32, int32) const
{
}
//------------------------------------------------------------------------------
void _BStyleBuffer_::RemoveStyles(int32 from, int32 to)
{
}
//------------------------------------------------------------------------------
void _BStyleBuffer_::RemoveStyleRange(int32 from, int32 to)
{
}
//------------------------------------------------------------------------------
int32 _BStyleBuffer_::OffsetToRun(int32 offset) const
{
if (offset == 0)
return 0;
for (int i = 0; i < fRuns.fCount; i++)
{
if (offset < fRuns.fItems[i].fOffset)
return i - 1;
}
return fRuns.fCount - 2;
}
//------------------------------------------------------------------------------
void _BStyleBuffer_::BumpOffset(int32 run, int32 offset)
{
for (int i = run; i < fRuns.fCount; i++)
fRuns.fItems[i].fOffset += offset;
}
//------------------------------------------------------------------------------
/*void _BStyleBuffer_::Iterate(int32, int32, _BInlineInput_ *, const BFont **,
const rgb_color **, float *, uint32 *) const
{
}*/
//------------------------------------------------------------------------------
STEStyleRecord *_BStyleBuffer_::operator[](int32 index)
{
if (index < fRecords.fCount)
return fRecords.fItems + index;
else
return NULL;
}
//------------------------------------------------------------------------------
/*
* $Log $
*
* $Id $
*
*/

99
src/kits/interface/BTextView/StyleBuffer.h Normal file
View File

@ -0,0 +1,99 @@
//------------------------------------------------------------------------------
// Copyright (c) 2001-2002, OpenBeOS
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File Name: StyleBuffer.h
// Author: Marc Flerackers (mflerackers@androme.be)
// Description: Style storage used by BTextView
//------------------------------------------------------------------------------
// Standard Includes -----------------------------------------------------------
// System Includes -------------------------------------------------------------
#include <SupportDefs.h>
#include <InterfaceDefs.h>
#include <Font.h>
// Project Includes ------------------------------------------------------------
// Local Includes --------------------------------------------------------------
#include "TextViewSupportBuffer.h"
// Local Defines ---------------------------------------------------------------
struct STEStyleRunDesc {
int32 fOffset;
int32 fStyle;
};
struct STEStyleRecord {
BFont fFont;
rgb_color fColor;
};
// Globals ---------------------------------------------------------------------
// _BStyleBuffer_ class --------------------------------------------------------
class _BStyleBuffer_ {
public:
_BStyleBuffer_(const BFont *, const rgb_color *);
virtual ~_BStyleBuffer_();
void SetNullStyle(uint32, const BFont *, const rgb_color *, int32);
void GetNullStyle(const BFont **, const rgb_color **) const;
void SyncNullStyle(int32);
void InvalidateNullStyle();
bool IsValidNullStyle() const;
void SetStyle(uint32, const BFont *, BFont *, const rgb_color *,
rgb_color *) const;
void GetStyle(uint32, BFont *, rgb_color *) const;
void SetStyleRange(int32, int32, int32, uint32 mode, const BFont *,
const rgb_color *);
int32 GetStyleRange(int32, int32) const;
void ContinuousGetStyle(BFont *, uint32 *, rgb_color *, bool *,
int32, int32) const;
void RemoveStyles(int32 from, int32 to);
void RemoveStyleRange(int32 from, int32 to);
int32 OffsetToRun(int32 offset) const;
void BumpOffset(int32 run, int32 offset);
// void Iterate(int32, int32, _BInlineInput_ *, const BFont **,
// const rgb_color **, float *, uint32 *) const;
STEStyleRecord *operator[](int32);
private:
_BTextViewSupportBuffer_<STEStyleRunDesc> fRuns;
_BTextViewSupportBuffer_<STEStyleRecord> fRecords;
STEStyleRecord fNullStyle;
};
//------------------------------------------------------------------------------
/*
* $Log $
*
* $Id $
*
*/

137
src/kits/interface/BTextView/TextGapBuffer.cpp Normal file
View File

@ -0,0 +1,137 @@
//------------------------------------------------------------------------------
// Copyright (c) 2001-2002, OpenBeOS
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File Name: TextGapBuffer.cpp
// Author: Marc Flerackers (mflerackers@androme.be)
// Description: Text storage used by BTextView
//------------------------------------------------------------------------------
// Standard Includes -----------------------------------------------------------
// System Includes -------------------------------------------------------------
// Project Includes ------------------------------------------------------------
// Local Includes --------------------------------------------------------------
#include "TextGapBuffer.h"
// Local Defines ---------------------------------------------------------------
// Globals ---------------------------------------------------------------------
//------------------------------------------------------------------------------
_BTextGapBuffer_::_BTextGapBuffer_()
: fText(NULL),
fLogicalBytes(0),
fPhysicalBytes(2048)
{
fText = new char[fPhysicalBytes];
*fText = '\0';
}
//------------------------------------------------------------------------------
_BTextGapBuffer_::~_BTextGapBuffer_()
{
delete[] fText;
}
//------------------------------------------------------------------------------
void _BTextGapBuffer_::InsertText(const char *text, int32 length, int32 offset)
{
// If needed, resize buffer
if (fPhysicalBytes < fLogicalBytes + length + 1)
Resize(fLogicalBytes + length + 1);
// Move text after insertion point
memcpy(fText + offset + length, fText + offset,
fLogicalBytes + 1 - offset);
// Copy new text
memcpy(fText + offset, text, length);
// Update used bytes
fLogicalBytes += length;
}
//------------------------------------------------------------------------------
void _BTextGapBuffer_::RemoveRange(int32 from, int32 to)
{
// Move text after deletion point
memcpy(fText + from, fText + to, fLogicalBytes + 1 - to);
// Update used bytes
fLogicalBytes -= to - from;
}
//------------------------------------------------------------------------------
char *_BTextGapBuffer_::Text()
{
if (fLogicalBytes == 0 || fText[fLogicalBytes - 1] != '\0')
{
if (fPhysicalBytes < fLogicalBytes + 1)
{
char *new_text = new char[fLogicalBytes + 1];
if (fText)
{
memcpy(new_text, fText, fLogicalBytes );
delete fText;
}
fText = new_text;
}
fText[fLogicalBytes] = '\0';
}
return fText;
}
//------------------------------------------------------------------------------
char *_BTextGapBuffer_::RealText()
{
return fText;
}
//------------------------------------------------------------------------------
char _BTextGapBuffer_::RealCharAt(int32 offset) const
{
return *(fText + offset);
}
//------------------------------------------------------------------------------
void _BTextGapBuffer_::Resize(int32 size)
{
if (fPhysicalBytes < size)
{
char *text = new char[size];
if (fText)
{
memcpy(text, fText, fLogicalBytes);
delete fText;
}
fText = text;
fPhysicalBytes = size;
}
}
//------------------------------------------------------------------------------
/*
* $Log $
*
* $Id $
*
*/

77
src/kits/interface/BTextView/TextGapBuffer.h Normal file
View File

@ -0,0 +1,77 @@
//------------------------------------------------------------------------------
// Copyright (c) 2001-2002, OpenBeOS
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File Name: TextGapBuffer.h
// Author: Marc Flerackers (mflerackers@androme.be)
// Description: Text storage used by BTextView
//------------------------------------------------------------------------------
// Standard Includes -----------------------------------------------------------
// System Includes -------------------------------------------------------------
#include "SupportDefs.h"
// Project Includes ------------------------------------------------------------
// Local Includes --------------------------------------------------------------
// Local Defines ---------------------------------------------------------------
// Globals ---------------------------------------------------------------------
// _BTextGapBuffer_ class ------------------------------------------------------
class _BTextGapBuffer_ {
public:
_BTextGapBuffer_();
virtual ~_BTextGapBuffer_();
void InsertText(const char *text, int32 length, int32 offset);
void RemoveRange(int32 from, int32 to);
char *Text();
char *RealText();
void GetString(int32 offset, int32 length, char *buffer);
void GetString(int32, int32 *);
char RealCharAt(int32 offset) const;
bool FindChar(char c, int32 inOffset, int32 *outOffset);
void SizeGapTo(int32);
void MoveGapTo(int32);
void InsertText(BFile *, int32, int32, int32);
bool PasswordMode() const;
void SetPasswordMode(bool);
void Resize(int32 size);
char *fText;
int32 fLogicalBytes;
int32 fPhysicalBytes;
};
//------------------------------------------------------------------------------
/*
* $Log $
*
* $Id $
*
*/

1637
src/kits/interface/BTextView/TextView.cpp Normal file
View File

File diff suppressed because it is too large Load Diff

445
src/kits/interface/BTextView/TextView.h Normal file
View File

@ -0,0 +1,445 @@
//------------------------------------------------------------------------------
// Copyright (c) 2001-2002, OpenBeOS
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File Name: TextView.h
// Author: Marc Flerackers (mflerackers@androme.be)
// Description: BTextView displays and manages styled text.
//------------------------------------------------------------------------------
#ifndef _TEXT_VIEW_H
#define _TEXT_VIEW_H
// Standard Includes -----------------------------------------------------------
// System Includes -------------------------------------------------------------
#include <BeBuild.h>
#include <View.h>
// Project Includes ------------------------------------------------------------
// Local Includes --------------------------------------------------------------
// Local Defines ---------------------------------------------------------------
// Globals ---------------------------------------------------------------------
struct text_run {
int32 offset; /* byte offset of first character of run*/
BFont *font; /* font of run*/
rgb_color color; /* color of run*/
};
struct text_run_array {
int32 count; /* number of text runs*/
text_run runs[1]; /* array of count number of runs*/
};
enum undo_state {
B_UNDO_UNAVAILABLE,
B_UNDO_TYPING,
B_UNDO_CUT,
B_UNDO_PASTE,
B_UNDO_CLEAR,
B_UNDO_DROP
};
class BBitmap;
class BClipboard;
class BFile;
class BList;
class _BTextGapBuffer_;
class _BLineBuffer_;
class _BStyleBuffer_;
class _BWidthBuffer_;
class _BUndoBuffer_;
class _BInlineInput_;
class _BTextTrackState_;
class _BTextChangeResult_;
extern "C" status_t _init_interface_kit_();
// BTextView class -------------------------------------------------------------
class BTextView : public BView {
public:
BTextView(BRect frame,
const char *name,
BRect textRect,
uint32 resizeMask,
uint32 flags = B_WILL_DRAW | B_PULSE_NEEDED);
BTextView(BRect frame,
const char *name,
BRect textRect,
const BFont *initialFont,
const rgb_color *initialColor,
uint32 resizeMask,
uint32 flags);
BTextView(BMessage *data);
virtual ~BTextView();
static BArchivable* Instantiate(BMessage *data);
virtual status_t Archive(BMessage *data, bool deep = true) const;
virtual void AttachedToWindow();
virtual void DetachedFromWindow();
virtual void Draw(BRect inRect);
virtual void MouseDown(BPoint where);
virtual void MouseUp(BPoint where);
virtual void MouseMoved(BPoint where,
uint32 code,
const BMessage *message);
virtual void WindowActivated(bool state);
virtual void KeyDown(const char *bytes, int32 numBytes);
virtual void Pulse();
virtual void FrameResized(float width, float height);
virtual void MakeFocus(bool focusState = true);
virtual void MessageReceived(BMessage *message);
virtual BHandler* ResolveSpecifier(BMessage *message,
int32 index,
BMessage *specifier,
int32 form,
const char *property);
virtual status_t GetSupportedSuites(BMessage *data);
virtual status_t Perform(perform_code d, void *arg);
void SetText(const char *inText,
const text_run_array *inRuns = NULL);
void SetText(const char *inText,
int32 inLength,
const text_run_array *inRuns = NULL);
void SetText(BFile *inFile,
int32 startOffset,
int32 inLength,
const text_run_array *inRuns = NULL);
void Insert(const char *inText,
const text_run_array *inRuns = NULL);
void Insert(const char *inText,
int32 inLength,
const text_run_array *inRuns = NULL);
void Insert(int32 startOffset,
const char *inText,
int32 inLength,
const text_run_array *inRuns = NULL);
void Delete();
void Delete(int32 startOffset, int32 endOffset);
const char* Text() const;
int32 TextLength() const;
void GetText(int32 offset,
int32 length,
char *buffer) const;
uchar ByteAt(int32 offset) const;
int32 CountLines() const;
int32 CurrentLine() const;
void GoToLine(int32 lineNum);
virtual void Cut(BClipboard *clipboard);
virtual void Copy(BClipboard *clipboard);
virtual void Paste(BClipboard *clipboard);
void Clear();
virtual bool AcceptsPaste(BClipboard *clipboard);
virtual bool AcceptsDrop(const BMessage *inMessage);
virtual void Select(int32 startOffset, int32 endOffset);
void SelectAll();
void GetSelection(int32 *outStart, int32 *outEnd) const;
void SetFontAndColor(const BFont *inFont,
uint32 inMode = B_FONT_ALL,
const rgb_color *inColor = NULL);
void SetFontAndColor(int32 startOffset,
int32 endOffset,
const BFont *inFont,
uint32 inMode = B_FONT_ALL,
const rgb_color *inColor = NULL);
void GetFontAndColor(int32 inOffset,
BFont *outFont,
rgb_color *outColor = NULL) const;
void GetFontAndColor(BFont *outFont,
uint32 *outMode,
rgb_color *outColor = NULL,
bool *outEqColor = NULL) const;
void SetRunArray(int32 startOffset,
int32 endOffset,
const text_run_array *inRuns);
text_run_array* RunArray(int32 startOffset,
int32 endOffset,
int32 *outSize = NULL) const;
int32 LineAt(int32 offset) const;
int32 LineAt(BPoint point) const;
BPoint PointAt(int32 inOffset, float *outHeight = NULL) const;
int32 OffsetAt(BPoint point) const;
int32 OffsetAt(int32 line) const;
virtual void FindWord(int32 inOffset,
int32 *outFromOffset,
int32 *outToOffset);
virtual bool CanEndLine(int32 offset);
float LineWidth(int32 lineNum = 0) const;
float LineHeight(int32 lineNum = 0) const;
float TextHeight(int32 startLine, int32 endLine) const;
void GetTextRegion(int32 startOffset,
int32 endOffset,
BRegion *outRegion) const;
virtual void ScrollToOffset(int32 inOffset);
void ScrollToSelection();
void Highlight(int32 startOffset, int32 endOffset);
void SetTextRect(BRect rect);
BRect TextRect() const;
void SetStylable(bool stylable);
bool IsStylable() const;
void SetTabWidth(float width);
float TabWidth() const;
void MakeSelectable(bool selectable = true);
bool IsSelectable() const;
void MakeEditable(bool editable = true);
bool IsEditable() const;
void SetWordWrap(bool wrap);
bool DoesWordWrap() const;
void SetMaxBytes(int32 max);
int32 MaxBytes() const;
void DisallowChar(uint32 aChar);
void AllowChar(uint32 aChar);
void SetAlignment(alignment flag);
alignment Alignment() const;
void SetAutoindent(bool state);
bool DoesAutoindent() const;
void SetColorSpace(color_space colors);
color_space ColorSpace() const;
void MakeResizable(bool resize, BView *resizeView = NULL);
bool IsResizable() const;
void SetDoesUndo(bool undo);
bool DoesUndo() const;
void HideTyping(bool enabled);
bool IsTypingHidden(void) const;
virtual void ResizeToPreferred();
virtual void GetPreferredSize(float *width, float *height);
virtual void AllAttached();
virtual void AllDetached();
static void* FlattenRunArray(const text_run_array *inArray,
int32 *outSize = NULL);
static text_run_array* UnflattenRunArray(const void *data,
int32 *outSize = NULL);
protected:
virtual void InsertText(const char *inText,
int32 inLength,
int32 inOffset,
const text_run_array *inRuns);
virtual void DeleteText(int32 fromOffset, int32 toOffset);
public:
virtual void Undo(BClipboard *clipboard);
undo_state UndoState(bool *isRedo) const;
protected:
virtual void GetDragParameters(BMessage *drag,
BBitmap **bitmap,
BPoint *point,
BHandler **handler);
/*----- Private or reserved -----------------------------------------*/
private:
friend status_t _init_interface_kit_();
friend class _BTextTrackState_;
#if _PR2_COMPATIBLE_
friend void _ReservedTextView2__9BTextViewFv(BTextView *object,
BMessage *drag,
BBitmap **bitmap,
BPoint *point,
BHandler **handler);
#endif
virtual void _ReservedTextView3();
virtual void _ReservedTextView4();
virtual void _ReservedTextView5();
virtual void _ReservedTextView6();
virtual void _ReservedTextView7();
virtual void _ReservedTextView8();
#if !_PR3_COMPATIBLE_
virtual void _ReservedTextView9();
virtual void _ReservedTextView10();
virtual void _ReservedTextView11();
virtual void _ReservedTextView12();
#endif
void InitObject(BRect textRect,
const BFont *initialFont,
const rgb_color *initialColor);
void HandleBackspace();
void HandleArrowKey(uint32 inArrowKey);
void HandleDelete();
void HandlePageKey(uint32 inPageKey);
void HandleAlphaKey(const char *bytes, int32 numBytes);
void Refresh(int32 fromOffset,
int32 toOffset,
bool erase,
bool scroll);
void RecalLineBreaks(int32 *startLine, int32 *endLine);
int32 FindLineBreak(int32 fromOffset,
float *outAscent,
float *outDescent,
float *ioWidth);
float StyledWidth(int32 fromOffset,
int32 length,
float *outAscent = NULL,
float *outDescent = NULL) const;
float ActualTabWidth(float location) const;
void DoInsertText(const char *inText,
int32 inLength,
int32 inOffset,
const text_run_array *inRuns,
_BTextChangeResult_ *outResult);
void DoDeleteText(int32 fromOffset,
int32 toOffset,
_BTextChangeResult_ *outResult);
void DrawLines(int32 startLine,
int32 endLine,
int32 startOffset = -1,
bool erase = false);
void DrawCaret(int32 offset);
void InvertCaret();
void DragCaret(int32 offset);
void StopMouseTracking();
bool PerformMouseUp(BPoint where);
bool PerformMouseMoved(BPoint where,
uint32 code);
void TrackMouse(BPoint where, const BMessage *message,
bool force = false);
void TrackDrag(BPoint where);
void InitiateDrag();
bool MessageDropped(BMessage *inMessage,
BPoint where,
BPoint offset);
void UpdateScrollbars();
void AutoResize(bool doredraw=true);
void NewOffscreen(float padding = 0.0F);
void DeleteOffscreen();
void Activate();
void Deactivate();
void NormalizeFont(BFont *font);
uint32 CharClassification(int32 offset) const;
int32 NextInitialByte(int32 offset) const;
int32 PreviousInitialByte(int32 offset) const;
bool GetProperty(BMessage *specifier,
int32 form,
const char *property,
BMessage *reply);
bool SetProperty(BMessage *specifier,
int32 form,
const char *property,
BMessage *reply);
bool CountProperties(BMessage *specifier,
int32 form,
const char *property,
BMessage *reply);
void HandleInputMethodChanged(BMessage *message);
void HandleInputMethodLocationRequest();
void CancelInputMethod();
static void LockWidthBuffer();
static void UnlockWidthBuffer();
_BTextGapBuffer_* fText;
_BLineBuffer_* fLines;
_BStyleBuffer_* fStyles;
BRect fTextRect;
int32 fSelStart;
int32 fSelEnd;
bool fCaretVisible;
bigtime_t fCaretTime;
int32 fClickOffset;
int32 fClickCount;
bigtime_t fClickTime;
int32 fDragOffset;
uint8 fCursor;
bool fActive;
bool fStylable;
float fTabWidth;
bool fSelectable;
bool fEditable;
bool fWrap;
int32 fMaxBytes;
BList* fDisallowedChars;
alignment fAlignment;
bool fAutoindent;
BBitmap* fOffscreen;
color_space fColorSpace;
bool fResizable;
BView* fContainerView;
_BUndoBuffer_* fUndo; /* was _reserved[0] */
_BInlineInput_* fInline; /* was _reserved[1] */
BMessageRunner * fDragRunner; /* was _reserved[2] */
BMessageRunner * fClickRunner; /* was _reserved[3] */
BPoint fWhere;
_BTextTrackState_* fTrackingMouse; /* was _reserved[6] */
_BTextChangeResult_* fTextChange; /* was _reserved[7] */
uint32 _reserved[1]; /* was 8 */
#if !_PR3_COMPATIBLE_
uint32 _more_reserved[8];
#endif
static _BWidthBuffer_* sWidths;
static sem_id sWidthSem;
static int32 sWidthAtom;
};
//------------------------------------------------------------------------------
#endif // _TEXT_VIEW_H
/*
* $Log $
*
* $Id $
*
*/

104
src/kits/interface/BTextView/TextViewSupportBuffer.h Normal file
View File

@ -0,0 +1,104 @@
//------------------------------------------------------------------------------
// Copyright (c) 2001-2002, OpenBeOS
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File Name: TextViewSupportBuffer.h
// Author: Marc Flerackers (mflerackers@androme.be)
// Description: Template class used to implement the various BTextView
// buffer classes.
//------------------------------------------------------------------------------
// Standard Includes -----------------------------------------------------------
#include <malloc.h>
// System Includes -------------------------------------------------------------
#include "SupportDefs.h"
// Project Includes ------------------------------------------------------------
// Local Includes --------------------------------------------------------------
// Local Defines ---------------------------------------------------------------
// Globals ---------------------------------------------------------------------
// _BTextViewSupportBuffer_ class ----------------------------------------------
template <class T>
class _BTextViewSupportBuffer_ {
public:
_BTextViewSupportBuffer_(int32 count, int32 blockSize);
virtual ~_BTextViewSupportBuffer_();
void InsertItemsAt(int32 offset, int32 count, const T *items);
void RemoveItemsAt(int32 offset, int32 count);
int32 fBlockSize;
int32 fCount;
int32 fPhysicalSize;
T *fItems;
int32 fReserved;
};
//------------------------------------------------------------------------------
template <class T>
_BTextViewSupportBuffer_<T>::_BTextViewSupportBuffer_(int32 count, int32 blockSize)
:
fBlockSize(blockSize),
fCount(count),
fPhysicalSize(count + blockSize),
fItems(NULL)
{
fItems = (T*)malloc(fPhysicalSize * sizeof(T));
}
//------------------------------------------------------------------------------
template <class T>
_BTextViewSupportBuffer_<T>::~_BTextViewSupportBuffer_()
{
free(fItems);
}
//------------------------------------------------------------------------------
template <class T>
void _BTextViewSupportBuffer_<T>::InsertItemsAt(int32 offset, int32 count,
const T *items)
{
if (fPhysicalSize < fCount + count)
{
int32 new_size = (((fCount + count) / fBlockSize) + 1) * fBlockSize;
fItems = realloc(fItems, new_size);
}
memcpy(fItems + offset, items, count);
fCount += count;
}
//------------------------------------------------------------------------------
template <class T>
void _BTextViewSupportBuffer_<T>::RemoveItemsAt(int32 offset, int32 count)
{
}
//------------------------------------------------------------------------------
/*
* $Log $
*
* $Id $
*
*/