FCL/sf/mw/hb: comparison src/hbwidgets/editors/hbabstractedit

equal deleted inserted replaced

-:730c025d4b77
+:f378acbc9cfb
 #include "hbabstractedit_p.h"
 #include "hbabstractedit.h"
 #include "hbstyleoption_p.h"
 #include "hbscrollarea.h"
 #include "hbvalidator.h"
-#include "hbmeshlayout_p.h"
 #include "hbmenu.h"
 #include "hbselectioncontrol_p.h"
 #include "hbcolorscheme.h"
 #include "hbsmileyengine_p.h"
 #include "hbtextmeasurementutility_p.h"
-#include "hbfeaturemanager_p.h"
+#include "hbfeaturemanager_r.h"
 #include "hbinputeditorinterface.h"
 #include "hbinputvkbhost.h"
+#include "hbinputmethod.h"
+#include "hbinputfocusobject.h"
 #include <QValidator>
 #include <QTextLayout>
 #include <QTextBlock>
 #include <QTextList>
 {
 public:
 HbEditItem(HbAbstractEdit *parent) : HbWidget(parent), edit(parent)
 {
+	setFlag(QGraphicsItem::ItemUsesExtendedStyleOption, true);
 };
 virtual ~HbEditItem() {};
 void paint(QPainter *painter, const QStyleOptionGraphicsItem *option, QWidget *widget = 0)
 acceptSignalContentsChanged(true),
 validRevision(0),
 wasGesture(false),
 smileysEnabled(false),
 smileyEngine(0),
-formatDialog(0)
+formatDialog(0),
+updatePrimitivesInProgress(false)
 {
 }
 HbAbstractEditPrivate::~HbAbstractEditPrivate ()
 {
 void HbAbstractEditPrivate::init()
 {
 Q_Q(HbAbstractEdit);
 canvas = new HbEditItem(q);
+canvas->setSizePolicy(QSizePolicy::Ignored,QSizePolicy::Ignored);
 setContent(Qt::RichText, QString());
 QTextOption textOption = doc->defaultTextOption();
 textOption.setTextDirection(q->layoutDirection());
 // These are the default values which are then overridden in subclasses
 // and when different options are enabled.
 q->setFlag(QGraphicsItem::ItemIsFocusable);
 q->setFlag(QGraphicsItem::ItemAcceptsInputMethod);
 q->setFlag(QGraphicsItem::ItemSendsScenePositionChanges);
+q->setFlag(QGraphicsItem::ItemHasNoContents, false);
 q->setFocusPolicy(Qt::StrongFocus);
 q->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
 contextMenuShownOn = Hb::ShowTextContextMenuOnSelectionClicked | Hb::ShowTextContextMenuOnLongPress;
 q->grabGesture(Qt::TapGesture);
 }
 void HbAbstractEditPrivate::updatePaletteFromTheme()
 {
-Q_Q(HbAbstractEdit);
-// TODO: remove once these color dissapear from hbcolorgroup.css
-QColor textColor = HbColorScheme::color("qtc_editor_normal");
-QColor selectedColor = HbColorScheme::color("qtc_editor_selected");
-QColor selectedBackground = HbColorScheme::color("qtc_editor_marker_normal");
-QPalette pal = q->palette();
-if (textColor.isValid()) {
-pal.setColor(QPalette::Text, textColor);
-}
-if (selectedColor.isValid()) {
-pal.setColor(QPalette::HighlightedText, selectedColor);
-}
-if (selectedBackground.isValid()) {
-pal.setColor(QPalette::Highlight, selectedBackground);
-}
-q->setPalette(pal);
 // The link color is used from application's palette
 QColor linkColor = HbColorScheme::color("qtc_view_link_normal");
 QColor linkVisitedColor = HbColorScheme::color("qtc_view_visited_normal");
 QPalette appPal = qApp->palette();
 if (linkColor.isValid()) {
 return false;
 }
 void HbAbstractEditPrivate::setCursorPosition(int pos, QTextCursor::MoveMode mode)
 {
+if (cursor.isNull()) {
+cursor = QTextCursor(doc);
+}
 cursor.setPosition(pos, mode);
+ensureCursorVisible();
 cursorChanged(HbValidator::CursorChangeFromMouse);
 }
 bool HbAbstractEditPrivate::cursorMoveKeyEvent(QKeyEvent *e)
 {
 #endif // QT_NO_SHORTCUT
 else {
 return false;
 }
-const QTextCursor oldCursor = cursor;
+//const QTextCursor oldCursor = cursor;
 bool visualNavigation = cursor.visualNavigation();
 cursor.setVisualNavigation(true);
 cursor.movePosition(op, mode);
 cursor.setVisualNavigation(visualNavigation);
 cursorChanged(HbValidator::CursorChangeFromOperation);
-repaintOldAndNewSelection(oldCursor);
 return true;
 }
 void HbAbstractEditPrivate::repaintOldAndNewSelection(const QTextCursor &oldSelection)
 }
 }
 void HbAbstractEditPrivate::setTextInteractionFlags(Qt::TextInteractionFlags flags)
 {
-Q_Q(HbAbstractEdit);
 if (flags == interactionFlags)
 return;
 interactionFlags = flags;
-if (q->hasFocus()) {
+if (hasInputFocus()) {
 setBlinkingCursorEnabled(flags & Qt::TextEditable);
 }
 }
 void HbAbstractEditPrivate::_q_updateRequest(QRectF rect)
 void HbAbstractEditPrivate::_q_selectionChanged()
 {
 Q_Q(HbAbstractEdit);
 if (cursor.hasSelection()) {
-if (selectionControl) {
+selectionControl = HbSelectionControl::attachEditor(q);
 selectionControl->showHandles();
-q->update();
-}
 } else if (selectionControl){
 selectionControl->hideHandles();
-q->update();
+}
-}
+QTextCursor oldSelection(selectionCursor);
+selectionCursor = cursor;
+repaintOldAndNewSelection(oldSelection);
 }
 void HbAbstractEditPrivate::_q_scrollStarted()
 {
 if (selectionControl) {
 return;
 }
 }
 emit q->selectionChanged(selectionCursor, cursor);
-selectionCursor = cursor;
 }
 void HbAbstractEditPrivate::acceptKeyPressEvent(QKeyEvent *event)
 {
 event->accept();
 }
 if (cursor.hasSelection()) {
 QAbstractTextDocumentLayout::Selection selection;
 selection.cursor = cursor;
-QPalette::ColorGroup cg = q->hasFocus() ? QPalette::Active : QPalette::Inactive;
+QPalette::ColorGroup cg = hasInputFocus() ? QPalette::Active : QPalette::Inactive;
 selection.format.setBackground(ctx.palette.brush(cg, QPalette::Highlight));
 selection.format.setForeground(ctx.palette.brush(cg, QPalette::HighlightedText));
 HbStyleOption opt;
 q->initStyleOption(&opt);
 Q_Q(const HbAbstractEdit);
 QTextLayout *layout = cursor.block().layout();
 int cursorPos = hitTest(tapPos, Qt::ExactHit);
-if (cursorPos == -1) {
+if (layout && cursorPos == -1) {
 cursorPos = cursor.position() + layout->preeditAreaText().length();
 }
 if (layout && !layout->preeditAreaText().isEmpty()) {
 QInputContext *ctx = qApp->inputContext();
 bool removeSelection = (hitTest(point, Qt::ExactHit) == -1);
 if (removeSelection && cursor.hasSelection()) {
 const QTextCursor oldCursor = cursor;
 cursor.clearSelection();
-repaintOldAndNewSelection(oldCursor);
 emit q->selectionChanged(oldCursor, cursor);
 }
 int newCursorPos = hitTest(point, Qt::FuzzyHit);
 q->showContextMenu(q->mapToScene(point));
 }
 } else {
 // Currently focused widget to listen to InputContext before updating the cursor position
 sendMouseEventToInputContext(point);
+// translate the point to have the Y ccordinate inside the viewport
+QPointF translatedPoint(point);
+if(translatedPoint.y() < viewPortRect().top()) {
+translatedPoint.setY(viewPortRect().top() + 1);
+} else if(translatedPoint.y() > viewPortRect().bottom()){
+translatedPoint.setY(viewPortRect().bottom() - 1);
+}
 // need to get the cursor position again since input context can change the document
-newCursorPos = hitTest(point, Qt::FuzzyHit);
+newCursorPos = hitTest(translatedPoint, Qt::FuzzyHit);
 setCursorPosition(newCursorPos);
 if (interactionFlags & Qt::TextEditable) {
 updateCurrentCharFormat();
 }
-cursorChanged(HbValidator::CursorChangeFromMouse);
+QString anchor(q->anchorAt(translatedPoint));
+if(!anchor.isEmpty()) {
+emit q->anchorTapped(anchor);
+}
 }
 }
 placeholderDoc->setDefaultTextOption(doc->defaultTextOption());
 placeholderDoc->setDefaultFont(doc->defaultFont());
 placeholderDoc->setTextWidth(doc->textWidth());
 }
 }
+void HbAbstractEditPrivate::filterInputText(QString &text) const
+{
+Q_Q(const HbAbstractEdit);
+HbEditorInterface editorInterface(const_cast<HbAbstractEdit*>(q));
+HbInputFilter *inputFilter = editorInterface.filter();
+if (!text.isEmpty() && inputFilter) {
+for(int i(text.length() - 1); i>=0; --i) {
+if (!inputFilter->filter(text.at(i))) {
+text.remove(i,1);
+}
+}
+}
+}
 Qt::Alignment HbAbstractEditPrivate::alignmentFromString(const QString &text)
 {
 Qt::Alignment align(0);
 static const struct {
 void HbAbstractEditPrivate::closeInputPanel()
 {
 sendInputPanelEvent(QEvent::CloseSoftwareInputPanel);
 }
-#include "hbinputeditorinterface.h"
+bool HbAbstractEditPrivate::hasInputFocus() const
-#include "hbinputvkbhost.h"
+{
+Q_Q(const HbAbstractEdit);
-void HbAbstractEditPrivate::minimizeInputPanel()
-{
+HbInputMethod* inputMethod = HbInputMethod::activeInputMethod();
-Q_Q(HbAbstractEdit);
+if (inputMethod && inputMethod->focusObject() &&
+qobject_cast<HbAbstractEdit*>(inputMethod->focusObject()->object()) == q) {
-HbEditorInterface ei(q);
+return true;
-HbVkbHost* vkbHost = ei.vkbHost();
+}
-vkbHost->minimizeKeypad();
+return false;
+}
+void HbAbstractEditPrivate::setInputFocusEnabled(bool enable)
+{
+QGraphicsItem *focusItem = focusPrimitive(HbWidget::FocusHighlightActive);
+if (focusItem) {
+focusItem->setVisible(enable);
+}
+setBlinkingCursorEnabled(enable);
+repaintOldAndNewSelection(selectionCursor);
 }
 #include "moc_hbabstractedit.cpp"

branch	GCC_SURGE
changeset 15	f378acbc9cfb
parent 7	923ff622b8b9
child 21	4633027730f5
child 34	ed14f46c0e55