From 2d9b3b0b2d3a3535a1b7cf1986eb827a6469bc08 Mon Sep 17 00:00:00 2001 From: Eugene Sandulenko Date: Thu, 2 Jan 2020 18:23:33 +0100 Subject: GRAPHICS: MACGUI: Initial code for MacEditableText --- graphics/macgui/maceditabletext.cpp | 535 ++++++++++++++++++++++++++++++++++++ 1 file changed, 535 insertions(+) create mode 100644 graphics/macgui/maceditabletext.cpp (limited to 'graphics/macgui/maceditabletext.cpp') diff --git a/graphics/macgui/maceditabletext.cpp b/graphics/macgui/maceditabletext.cpp new file mode 100644 index 0000000000..5295566b11 --- /dev/null +++ b/graphics/macgui/maceditabletext.cpp @@ -0,0 +1,535 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ + +#include "common/timer.h" +#include "common/system.h" + +#include "graphics/macgui/macwindowmanager.h" +#include "graphics/macgui/macfontmanager.h" +#include "graphics/macgui/maceditabletext.h" +#include "graphics/macgui/macmenu.h" +#include "graphics/macgui/macwidget.h" +#include "graphics/macgui/macwindow.h" + +namespace Graphics { + +enum { + kConWOverlap = 20, + kConHOverlap = 20, + kConWPadding = 3, + kConHPadding = 4, + kConOverscan = 3, + kConScrollStep = 12, + + kCursorHeight = 12 +}; + +static void cursorTimerHandler(void *refCon); + +MacEditableText::MacEditableText(Common::U32String s, MacWindow *parent, const MacFont *macFont, int fgcolor, int bgcolor, int maxWidth, TextAlign textAlignment, int interlinear) : + MacText(s, parent->_wm, macFont, fgcolor, bgcolor, maxWidth, textAlignment, interlinear), MacWidget(0, true, parent) { + + _parent = parent; + _maxWidth = maxWidth; + + init(); +} + +MacEditableText::MacEditableText(const Common::String &s, MacWindow *parent, const MacFont *macFont, int fgcolor, int bgcolor, int maxWidth, TextAlign textAlignment, int interlinear) : + MacText(s, parent->_wm, macFont, fgcolor, bgcolor, maxWidth, textAlignment, interlinear), MacWidget(0, true, parent) { + + _parent = parent; + _maxWidth = maxWidth; + + init(); +} + +void MacEditableText::init() { + _inputTextHeight = 0; + + _inputIsDirty = true; + _inTextSelection = false; + + _scrollPos = 0; + _editable = true; + _selectable = true; + + _cursorX = 0; + _cursorY = 0; + _cursorState = false; + _cursorOff = false; + + _cursorDirty = true; + + _scrollbarIsDirty = false; + + _cursorRect = new Common::Rect(0, 0, 1, kCursorHeight); + + _cursorSurface = new ManagedSurface(1, kCursorHeight); + _cursorSurface->fillRect(*_cursorRect, _wm->_colorBlack); + + g_system->getTimerManager()->installTimerProc(&cursorTimerHandler, 200000, this, "macEditableText"); +} + +MacEditableText::~MacEditableText() { + delete _cursorRect; + delete _cursorSurface; + + g_system->getTimerManager()->removeTimerProc(&cursorTimerHandler); +} + +void MacEditableText::resize(int w, int h) { + if (_surface->w == w && _surface->h == h) + return; + + undrawInput(); + + _maxWidth = w; + MacText::setMaxWidth(_maxWidth); +} + +void MacEditableText::appendText(Common::U32String str, const MacFont *macFont, bool skipAdd) { + MacText::appendText(str, macFont->getId(), macFont->getSize(), macFont->getSlant(), skipAdd); + + _contentIsDirty = true; + + if (_editable) { + _scrollPos = MAX(0, MacText::getTextHeight() - getDimensions().height()); + + updateCursorPos(); + } +} + +void MacEditableText::appendText(const Common::String &str, const MacFont *macFont, bool skipAdd) { + appendText(Common::U32String(str), macFont, skipAdd); +} + +void MacEditableText::clearText() { + MacText::clearText(); + + _contentIsDirty = true; + _scrollbarIsDirty = true; + + updateCursorPos(); +} + +void MacEditableText::setTextWindowFont(const MacFont *font) { + _font = font; + + _fontRef = _wm->_fontMan->getFont(*font); + + MacText::setDefaultFormatting(font->getId(), font->getSlant(), font->getSize(), 0, 0, 0); +} + +const MacFont *MacEditableText::getTextWindowFont() { + return _font; +} + +bool MacEditableText::draw(ManagedSurface *g, bool forceRedraw) { + if (!_scrollbarIsDirty && !_contentIsDirty && !_cursorDirty && !_inputIsDirty && !forceRedraw) + return false; + + if (_scrollbarIsDirty || forceRedraw) { + drawScrollbar(); + + _composeSurface.clear(_wm->_colorWhite); + } + + if (_inputIsDirty || forceRedraw) { + drawInput(); + _inputIsDirty = false; + } + + _contentIsDirty = false; + + // Compose + MacText::draw(&_composeSurface, 0, _scrollPos, _surface->w - 2, _scrollPos + _surface->h - 2, kConWOverlap - 2, kConWOverlap - 2); + + if (_cursorState) + _composeSurface.blitFrom(*_cursorSurface, *_cursorRect, Common::Point(_cursorX + kConWOverlap - 2, _cursorY + kConHOverlap - 2)); + + if (_selectedText.endY != -1) + drawSelection(); + + //_composeSurface.transBlitFrom(_borderSurface, kColorGreen); + + g->transBlitFrom(_composeSurface, _composeSurface.getBounds(), Common::Point(_dims.left - 2, _dims.top - 2), kColorGreen2); + + return true; +} + +void MacEditableText::drawSelection() { + if (_selectedText.endY == -1) + return; + + SelectedText s = _selectedText; + + if (s.startY > s.endY || (s.startY == s.endY && s.startX > s.endX)) { + SWAP(s.startX, s.endX); + SWAP(s.startY, s.endY); + SWAP(s.startRow, s.endRow); + SWAP(s.startCol, s.endCol); + } + + int lastLineStart = s.endY; + s.endY += MacText::getLineHeight(s.endRow); + + int start = s.startY - _scrollPos; + start = MAX(0, start); + + if (start > getDimensions().height()) + return; + + int end = s.endY - _scrollPos; + + if (end < 0) + return; + + end = MIN((int)getDimensions().height(), end); + + int numLines = 0; + int x1 = 0, x2 = 0; + + for (int y = start; y < end; y++) { + if (!numLines) { + x1 = 0; + x2 = getDimensions().width() - 1; + + if (y + _scrollPos == s.startY && s.startX > 0) { + numLines = MacText::getLineHeight(s.startRow); + x1 = s.startX; + } + if (y + _scrollPos >= lastLineStart) { + numLines = MacText::getLineHeight(s.endRow); + x2 = s.endX; + } + } else { + numLines--; + } + + byte *ptr = (byte *)_composeSurface.getBasePtr(x1 + kConWOverlap - 2, y + kConWOverlap - 2); + + for (int x = x1; x < x2; x++, ptr++) + if (*ptr == _wm->_colorBlack) + *ptr = _wm->_colorWhite; + else + *ptr = _wm->_colorBlack; + } +} + +Common::U32String MacEditableText::getSelection(bool formatted, bool newlines) { + if (_selectedText.endY == -1) + return Common::U32String(""); + + SelectedText s = _selectedText; + + if (s.startY > s.endY || (s.startY == s.endY && s.startX > s.endX)) { + SWAP(s.startRow, s.endRow); + SWAP(s.startCol, s.endCol); + } + + return MacText::getTextChunk(s.startRow, s.startCol, s.endRow, s.endCol, formatted, newlines); +} + +void MacEditableText::clearSelection() { + _selectedText.endY = _selectedText.startY = -1; +} + +bool MacEditableText::isCutAllowed() { + if (_selectedText.startRow >= (int)(MacText::getLineCount() - _inputTextHeight) && + _selectedText.endRow >= (int)(MacText::getLineCount() - _inputTextHeight)) + return true; + + return false; +} + +Common::U32String MacEditableText::cutSelection() { + if (!isCutAllowed()) + return Common::U32String(""); + + SelectedText s = _selectedText; + + if (s.startY > s.endY || (s.startY == s.endY && s.startX > s.endX)) { + SWAP(s.startRow, s.endRow); + SWAP(s.startCol, s.endCol); + } + + Common::U32String selection = MacText::getTextChunk(s.startRow, s.startCol, s.endRow, s.endCol, false, false); + + uint32 selPos = _inputText.find(selection); + + if (selPos == Common::U32String::npos) { + //warning("Cannot find substring '%s' in '%s'", selection.c_str(), _inputText.c_str()); // Needed encode method + + return Common::U32String(""); + } + + Common::U32String newInput = Common::U32String(_inputText.c_str(), selPos) + Common::U32String(_inputText.c_str() + selPos + selection.size()); + + clearSelection(); + clearInput(); + appendInput(newInput); + + return selection; +} + +bool MacEditableText::processEvent(Common::Event &event) { + WindowClick click = kBorderInner; //_parent->isInBorder(event.mouse.x, event.mouse.y); + + if (event.type == Common::EVENT_KEYDOWN) { + if (!_editable) + return false; + + _wm->setActive(getId()); + + if (event.kbd.flags & (Common::KBD_ALT | Common::KBD_CTRL | Common::KBD_META)) { + return false; + } + + switch (event.kbd.keycode) { + case Common::KEYCODE_BACKSPACE: + if (!_inputText.empty()) { + _inputText.deleteLastChar(); + _inputIsDirty = true; + } + return true; + + case Common::KEYCODE_RETURN: + undrawInput(); + return false; // Pass it to the higher level for processing + + default: + if (event.kbd.ascii == '~') + return false; + + if (event.kbd.ascii >= 0x20 && event.kbd.ascii <= 0x7f) { + _inputText += (char)event.kbd.ascii; + _inputIsDirty = true; + + return true; + } + + break; + } + } + + if (hasAllFocus()) + return _parent->processEvent(event); // Pass it to upstream + + if (event.type == Common::EVENT_WHEELUP) { + scroll(-2); + return true; + } + + if (event.type == Common::EVENT_WHEELDOWN) { + scroll(2); + return true; + } + + if (click == kBorderScrollUp || click == kBorderScrollDown) { + if (event.type == Common::EVENT_LBUTTONDOWN) { + int consoleHeight = getDimensions().height(); + int textFullSize = MacText::getTextHeight(); + float scrollPos = (float)_scrollPos / textFullSize; + float scrollSize = (float)consoleHeight / textFullSize; + + setScroll(scrollPos, scrollSize); + + return true; + } else if (event.type == Common::EVENT_LBUTTONUP) { + switch (click) { + case kBorderScrollUp: + scroll(-1); + break; + case kBorderScrollDown: + scroll(1); + break; + default: + return false; + } + + return true; + } + + return false; + } + + if (click == kBorderInner) { + if (!_selectable) + return false; + + if (event.type == Common::EVENT_LBUTTONDOWN) { + startMarking(event.mouse.x, event.mouse.y); + + return true; + } else if (event.type == Common::EVENT_LBUTTONUP && _menu) { + if (_inTextSelection) { + _inTextSelection = false; + + if (_selectedText.endY == -1 || + (_selectedText.endX == _selectedText.startX && _selectedText.endY == _selectedText.startY)) { + _selectedText.startY = _selectedText.endY = -1; + _contentIsDirty = true; + _menu->enableCommand("Edit", "Copy", false); + } else { + _menu->enableCommand("Edit", "Copy", true); + + bool cutAllowed = isCutAllowed(); + + _menu->enableCommand("Edit", "Cut", cutAllowed); + _menu->enableCommand("Edit", "Clear", cutAllowed); + } + } + + return true; + } else if (event.type == Common::EVENT_MOUSEMOVE) { + if (_inTextSelection) { + updateTextSelection(event.mouse.x, event.mouse.y); + return true; + } + } + + return false; + } + + return _parent->processEvent(event); +} + +void MacEditableText::scroll(int delta) { + int oldScrollPos = _scrollPos; + + _scrollPos += delta * kConScrollStep; + + if (_editable) + _scrollPos = CLIP(_scrollPos, 0, MacText::getTextHeight() - kConScrollStep); + else + _scrollPos = CLIP(_scrollPos, 0, MAX(0, MacText::getTextHeight() - getDimensions().height())); + + undrawCursor(); + _cursorY -= (_scrollPos - oldScrollPos); + _contentIsDirty = true; + _scrollbarIsDirty = true; +} + +void MacEditableText::startMarking(int x, int y) { + x -= getDimensions().left - 2; + y -= getDimensions().top; + + y += _scrollPos; + + MacText::getRowCol(x, y, &_selectedText.startX, &_selectedText.startY, &_selectedText.startRow, &_selectedText.startCol); + + _selectedText.endY = -1; + + _inTextSelection = true; +} + +void MacEditableText::updateTextSelection(int x, int y) { + x -= getDimensions().left - 2; + y -= getDimensions().top; + + y += _scrollPos; + + MacText::getRowCol(x, y, &_selectedText.endX, &_selectedText.endY, &_selectedText.endRow, &_selectedText.endCol); + + debug(3, "s: %d,%d (%d, %d) e: %d,%d (%d, %d)", _selectedText.startX, _selectedText.startY, + _selectedText.startRow, _selectedText.startCol, _selectedText.endX, + _selectedText.endY, _selectedText.endRow, _selectedText.endCol); + + _contentIsDirty = true; +} + +void MacEditableText::undrawInput() { + for (uint i = 0; i < _inputTextHeight; i++) + MacText::removeLastLine(); + + if (_inputTextHeight) + appendText("\n", _font, true); + + _inputTextHeight = 0; +} + +void MacEditableText::drawInput() { + undrawInput(); + + Common::Array text; + + // Now recalc new text height + _fontRef->wordWrapText(_inputText, _maxWidth, text); + _inputTextHeight = MAX((uint)1, text.size()); // We always have line to clean + + // And add new input line to the text + appendText(_inputText, _font, true); + + _cursorX = _inputText.empty() ? 0 : _fontRef->getStringWidth(text[_inputTextHeight - 1]); + + updateCursorPos(); + + _contentIsDirty = true; +} + +void MacEditableText::clearInput() { + undrawCursor(); + + _cursorX = 0; + _inputText.clear(); +} + +void MacEditableText::appendInput(Common::U32String str) { + _inputText += str; + + drawInput(); +} + +void MacEditableText::appendInput(const Common::String &str) { + appendInput(Common::U32String(str)); +} + +////////////////// +// Cursor stuff +static void cursorTimerHandler(void *refCon) { + MacEditableText *w = (MacEditableText *)refCon; + + if (!w->_cursorOff) + w->_cursorState = !w->_cursorState; + + w->_cursorDirty = true; +} + +void MacEditableText::updateCursorPos() { + _cursorY = MacText::getTextHeight() - _scrollPos - kCursorHeight; + + _cursorDirty = true; +} + +void MacEditableText::undrawCursor() { + _cursorState = false; + _cursorDirty = true; +} + +void MacEditableText::setScroll(float scrollPos, float scrollSize) { +} + +void MacEditableText::drawScrollbar() { +} + +} // End of namespace Graphics -- cgit v1.2.3