Merge branch 'develop' of github.com:Sankore/Sankore-3.1 into aleksei_kanash_dev

src/api/UBWidgetUniboardAPI.cpp

@@ -250,7 +250,7 @@ void UBWidgetUniboardAPI::eraseLineTo(const qreal x, const qreal y, const qreal
 void UBWidgetUniboardAPI::clear()
 {
     if (mScene)
-            mScene->clearItemsAndAnnotations();
+            mScene->clearContent(UBGraphicsScene::clearItemsAndAnnotations);
 }
 
 

src/board/UBBoardController.cpp

@@ -683,7 +683,7 @@ void UBBoardController::clearScene()
     if (mActiveScene)
     {
         freezeW3CWidgets(true);
-        mActiveScene->clearItemsAndAnnotations();
+        mActiveScene->clearContent(UBGraphicsScene::clearItemsAndAnnotations);
         updateActionStates();
     }
 }
@@ -694,7 +694,7 @@ void UBBoardController::clearSceneItems()
     if (mActiveScene)
     {
         freezeW3CWidgets(true);
-        mActiveScene->clearItems();
+        mActiveScene->clearContent(UBGraphicsScene::clearItems);
         updateActionStates();
     }
 }
@@ -704,7 +704,7 @@ void UBBoardController::clearSceneAnnotation()
 {
     if (mActiveScene)
     {
-        mActiveScene->clearAnnotations();
+        mActiveScene->clearContent(UBGraphicsScene::clearAnnotations);
         updateActionStates();
     }
 }
@@ -713,7 +713,7 @@ void UBBoardController::clearSceneBackground()
 {
     if (mActiveScene)
     {
-        mActiveScene->clearBackground();
+        mActiveScene->clearContent(UBGraphicsScene::clearBackground);
         updateActionStates();
     }
 }
@@ -1551,7 +1551,6 @@ void UBBoardController::changeBackground(bool isDark, bool isCrossed)
     }
 }
 
-
 void UBBoardController::boardViewResized(QResizeEvent* event)
 {
     Q_UNUSED(event);

src/desktop/UBDesktopAnnotationController.cpp

@@ -274,7 +274,7 @@ void UBDesktopAnnotationController::eraseDesktopAnnotations()
 {
     if (mTransparentDrawingScene)
     {
-        mTransparentDrawingScene->clearAnnotations();
+        mTransparentDrawingScene->clearContent(UBGraphicsScene::clearAnnotations);
     }
 }
 

src/domain/UBGraphicsGroupContainerItem.cpp

@@ -78,7 +78,10 @@ void UBGraphicsGroupContainerItem::addToGroup(QGraphicsItem *item)
     QTransform newItemTransform(itemTransform);
     item->setPos(mapFromItem(item, 0, 0));
 
-    item->scene()->removeItem(item);
+    if (item->scene()) {
+        item->scene()->removeItem(item);
+    }
+
     if (corescene())
         corescene()->removeItemFromDeletion(item);
     item->setParentItem(this);

src/domain/UBGraphicsItemDelegate.cpp

@@ -387,9 +387,22 @@ void UBGraphicsItemDelegate::remove(bool canUndo)
     UBGraphicsScene* scene = dynamic_cast<UBGraphicsScene*>(mDelegated->scene());
     if (scene)
     {
-        foreach(DelegateButton* button, mButtons)
-            scene->removeItem(button);
+//        bool shownOnDisplay = mDelegated->data(UBGraphicsItemData::ItemLayerType).toInt() != UBItemLayerType::Control;
+//        showHide(shownOnDisplay);
+//        updateFrame();
+//        updateButtons();
+
+        if (mFrame && !mFrame->scene() && mDelegated->scene())
+        {
+            mDelegated->scene()->addItem(mFrame);
+        }
+        mFrame->setAntiScale(mAntiScaleRatio);
+        mFrame->positionHandles();
+        updateButtons(true);
 
+        foreach(DelegateButton* button, mButtons) {
+            scene->removeItem(button);
+        }
         scene->removeItem(mFrame);
 
         /* this is performed because when removing delegated from scene while it contains flash content, segfault happens because of QGraphicsScene::removeItem() */

src/domain/UBGraphicsItemDelegate.h

@@ -244,6 +244,7 @@ class UBGraphicsItemDelegate : public QObject
         UBGraphicsToolBarItem* getToolBarItem() const { return mToolBarItem; }
 
         qreal antiScaleRatio() const { return mAntiScaleRatio; }
+        virtual void update() {positionHandles();}
 
     signals:
         void showOnDisplayChanged(bool shown);

src/domain/UBGraphicsScene.cpp

@@ -902,25 +902,18 @@ void UBGraphicsScene::recolorAllItems()
         view->setViewportUpdateMode(QGraphicsView::NoViewportUpdate);
     }
 
-    for(int i = 0; i < mFastAccessItems.size(); i++)
-    {
-        UBGraphicsPolygonItem *polygonItem = qgraphicsitem_cast<UBGraphicsPolygonItem*> (mFastAccessItems.at(i));
-
-        if (polygonItem)
-        {
-            QColor color;
-
-            if (mDarkBackground)
-            {
-                color = polygonItem->colorOnDarkBackground();
-            }
-            else
-            {
-                color = polygonItem->colorOnLightBackground();
+    bool currentIslight = isLightBackground();
+    foreach (QGraphicsItem *item, items()) {
+        if (item->type() == UBGraphicsStrokesGroup::Type) {
+            UBGraphicsStrokesGroup *curGroup = static_cast<UBGraphicsStrokesGroup*>(item);
+            QColor compareColor =  curGroup->color(currentIslight ? UBGraphicsStrokesGroup::colorOnDarkBackground
+                                                                  : UBGraphicsStrokesGroup::colorOnLightBackground);
+
+            if (curGroup->color() == compareColor) {
+                QColor newColor = curGroup->color(!currentIslight ? UBGraphicsStrokesGroup::colorOnDarkBackground
+                                                                  : UBGraphicsStrokesGroup::colorOnLightBackground);
+                curGroup->setColor(newColor);
             }
-
-            polygonItem->setColor(color);
-            continue;
         }
     }
 
@@ -1071,106 +1064,72 @@ UBItem* UBGraphicsScene::deepCopy() const
     return sceneDeepCopy();
 }
 
-void UBGraphicsScene::clearItemsAndAnnotations()
-{
-    deselectAllItems();
-
-    QSet<QGraphicsItem*> emptyList;
-    QSet<QGraphicsItem*> removedItems;
-
-    QList<QGraphicsItem*> sceneItems = items();
-    foreach(QGraphicsItem* item, sceneItems)
-    {
-        if(!mTools.contains(item) && !isBackgroundObject(item))
-        {
-            removeItem(item);
-            removedItems << item;
-        }
-    }
-
-    // force refresh, QT is a bit lazy and take a lot of time (nb item ^2 ?) to trigger repaint
-    update(sceneRect());
-
-    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
-        UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, removedItems, emptyList);
-        UBApplication::undoStack->push(uc);
-    }
-
-    setDocumentUpdated();
-}
-
-void UBGraphicsScene::clearItems()
+void UBGraphicsScene::clearContent(clearCase pCase)
 {
-    deselectAllItems();
-
-    QSet<QGraphicsItem*> emptyList;
     QSet<QGraphicsItem*> removedItems;
 
-    QList<QGraphicsItem*> sceneItems = items();
-    foreach(QGraphicsItem* item, sceneItems)
-    {
-        bool isGroup = qgraphicsitem_cast<UBGraphicsGroupContainerItem*>(item) != NULL;
-        bool isPolygon = qgraphicsitem_cast<UBGraphicsPolygonItem*>(item) != NULL;
-        bool isStrokesGroup = qgraphicsitem_cast<UBGraphicsStrokesGroup*>(item) != NULL;
-
-        if(!isGroup && !isPolygon && !isStrokesGroup && !mTools.contains(item) && !isBackgroundObject(item))
-        {
-            removeItem(item);
-            removedItems << item;
-        }
-    }
-
-    // force refresh, QT is a bit lazy and take a lot of time (nb item ^2 ?) to trigger repaint
-    update(sceneRect());
-
-
-    if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
-        UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, removedItems, emptyList);
-        UBApplication::undoStack->push(uc);
-    }
+    switch (pCase) {
+    case clearBackground :
+        removeItem(mBackgroundObject);
+        removedItems << mBackgroundObject;
+        break;
+
+    case clearItemsAndAnnotations :
+    case clearItems :
+    case clearAnnotations :
+        foreach(QGraphicsItem* item, items()) {
+
+            bool isGroup = item->type() == UBGraphicsGroupContainerItem::Type;
+            bool isStrokesGroup = item->type() == UBGraphicsStrokesGroup::Type;
+
+            UBGraphicsGroupContainerItem *itemGroup = item->parentItem()
+                                                      ? qgraphicsitem_cast<UBGraphicsGroupContainerItem*>(item->parentItem())
+                                                      : 0;
+            UBGraphicsItemDelegate *curDelegate = UBGraphicsItem::Delegate(item);
+            if (!curDelegate) {
+                continue;
+            }
 
-    setDocumentUpdated();
-}
+            bool shouldDelete = false;
+            switch (static_cast<int>(pCase)) {
+            case clearAnnotations :
+                shouldDelete = isStrokesGroup;
+                break;
+            case clearItems :
+                shouldDelete = !isGroup && !isBackgroundObject(item) && !isStrokesGroup;
+                break;
+            case clearItemsAndAnnotations:
+                shouldDelete = !isGroup && !isBackgroundObject(item);
+                break;
+            }
 
-void UBGraphicsScene::clearAnnotations()
-{
-    QSet<QGraphicsItem*> emptyList;
-    QSet<QGraphicsItem*> removedItems;
+            if(shouldDelete) {
+                if (itemGroup) {
+                    itemGroup->removeFromGroup(item);
+                    if (itemGroup->childItems().count() == 1) {
+                        itemGroup->destroy();
+                    }
+                    itemGroup->Delegate()->update();
+                }
 
-    QList<QGraphicsItem*> sceneItems = items();
-    foreach(QGraphicsItem* item, sceneItems)
-    {
-        UBGraphicsStrokesGroup* pi = qgraphicsitem_cast<UBGraphicsStrokesGroup*>(item);
-        if (pi)
-        {
-            removeItem(item);
-            removedItems << item;
+                curDelegate->remove(false);
+                removedItems << item;
+            }
         }
+        break;
     }
 
     // force refresh, QT is a bit lazy and take a lot of time (nb item ^2 ?) to trigger repaint
     update(sceneRect());
 
     if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
-        UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, removedItems, emptyList);
+        UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, removedItems, QSet<QGraphicsItem*>());
         UBApplication::undoStack->push(uc);
     }
 
-    setDocumentUpdated();
-}
-
-void UBGraphicsScene::clearBackground()
-{
-    if(mBackgroundObject){
-        removeItem(mBackgroundObject);
-
-        if (enableUndoRedoStack) { //should be deleted after scene own undo stack implemented
-            UBGraphicsItemUndoCommand* uc = new UBGraphicsItemUndoCommand(this, mBackgroundObject, NULL);
-            UBApplication::undoStack->push(uc);
-        }
+    if (pCase == clearBackground) {
         mBackgroundObject = 0;
     }
-    update(sceneRect());
 
     setDocumentUpdated();
 }
@@ -1364,8 +1323,8 @@ UBGraphicsW3CWidgetItem* UBGraphicsScene::addOEmbed(const QUrl& pContentUrl, con
 UBGraphicsGroupContainerItem *UBGraphicsScene::createGroup(QList<QGraphicsItem *> items)
 {
     UBGraphicsGroupContainerItem *groupItem = new UBGraphicsGroupContainerItem();
-    addItem(groupItem);
 
+    addItem(groupItem);
     foreach (QGraphicsItem *item, items) {
         if (item->type() == UBGraphicsGroupContainerItem::Type) {
             QList<QGraphicsItem*> childItems = item->childItems();

src/domain/UBGraphicsScene.h

@@ -101,6 +101,13 @@ class UBGraphicsScene: public UBCoreGraphicsScene, public UBItem
 
     public:
 
+    enum clearCase {
+        clearItemsAndAnnotations = 0
+        , clearAnnotations
+        , clearItems
+        , clearBackground
+    };
+
     //        tmp stub for divide addings scene objects from undo mechanism implementation
     void setURStackEnable(bool set = true) {enableUndoRedoStack = set;}
     bool isURStackIsEnabled(){ return enableUndoRedoStack;}
@@ -114,10 +121,7 @@ class UBGraphicsScene: public UBCoreGraphicsScene, public UBItem
 
         UBGraphicsScene* sceneDeepCopy() const;
 
-        void clearItemsAndAnnotations();
-        void clearItems();
-        void clearAnnotations();
-        void clearBackground();
+        void clearContent(clearCase pCase = clearItemsAndAnnotations);
 
         bool inputDevicePress(const QPointF& scenePos, const qreal& pressure = 1.0);
         bool inputDeviceMove(const QPointF& scenePos, const qreal& pressure = 1.0);

src/domain/UBGraphicsStrokesGroup.cpp

@@ -32,6 +32,54 @@ void UBGraphicsStrokesGroup::setUuid(const QUuid &pUuid)
     UBItem::setUuid(pUuid);
     setData(UBGraphicsItemData::ItemUuid, QVariant(pUuid)); //store item uuid inside the QGraphicsItem to fast operations with Items on the scene
 }
+void UBGraphicsStrokesGroup::setColor(const QColor &color, colorType pColorType)
+{
+    //TODO Implement common mechanism of managing groups, drop UBGraphicsStroke if it's obsolete
+    //Using casting for the moment
+    foreach (QGraphicsItem *item, childItems()) {
+        if (item->type() == UBGraphicsPolygonItem::Type) {
+            UBGraphicsPolygonItem *curPolygon = static_cast<UBGraphicsPolygonItem *>(item);
+
+            switch (pColorType) {
+            case currentColor :
+                curPolygon->setColor(color);
+                break;
+            case colorOnLightBackground :
+                 curPolygon->setColorOnLightBackground(color);
+                break;
+            case colorOnDarkBackground :
+                 curPolygon->setColorOnDarkBackground(color);
+                break;
+            }
+        }
+    }
+}
+
+QColor UBGraphicsStrokesGroup::color(colorType pColorType) const
+{
+    QColor result;
+
+    foreach (QGraphicsItem *item, childItems()) {
+        if (item->type() == UBGraphicsPolygonItem::Type) {
+            UBGraphicsPolygonItem *curPolygon = static_cast<UBGraphicsPolygonItem *>(item);
+
+            switch (pColorType) {
+            case currentColor :
+                result = curPolygon->color();
+                break;
+            case colorOnLightBackground :
+                result = curPolygon->colorOnLightBackground();
+                break;
+            case colorOnDarkBackground :
+                result = curPolygon->colorOnDarkBackground();
+                break;
+            }
+
+        }
+    }
+
+    return result;
+}
 
 void UBGraphicsStrokesGroup::mousePressEvent(QGraphicsSceneMouseEvent *event)
 {

src/domain/UBGraphicsStrokesGroup.h

@@ -11,6 +11,12 @@ class UBGraphicsStrokesGroup : public QObject, public QGraphicsItemGroup, public
 {
     Q_OBJECT
 public:
+    enum colorType {
+        currentColor = 0
+        , colorOnLightBackground
+        , colorOnDarkBackground
+    };
+
     UBGraphicsStrokesGroup(QGraphicsItem* parent = 0);
     ~UBGraphicsStrokesGroup();
     virtual UBItem* deepCopy() const;
@@ -23,6 +29,8 @@ public:
         return Type;
     }
     virtual void setUuid(const QUuid &pUuid);
+    void setColor(const QColor &color, colorType pColorType = currentColor);
+    QColor color(colorType pColorType = currentColor) const;
 
 protected:
 

src/domain/UBGraphicsTextItemDelegate.cpp

@@ -263,6 +263,11 @@ void UBGraphicsTextItemDelegate::setEditable(bool editable)
         mDelegated->setData(UBGraphicsItemData::ItemEditable, QVariant(false));
     }
 }
+void UBGraphicsTextItemDelegate::remove(bool canUndo)
+{
+    UBGraphicsItemDelegate::remove(canUndo);
+}
+
 bool UBGraphicsTextItemDelegate::isEditable()
 {
     return mDelegated->data(UBGraphicsItemData::ItemEditable).toBool();

src/domain/UBGraphicsTextItemDelegate.h

@@ -46,6 +46,7 @@ class UBGraphicsTextItemDelegate : public UBGraphicsItemDelegate
     public slots:
         void contentsChanged();
         virtual void setEditable(bool);
+        virtual void remove(bool canUndo);
 
     protected:
         virtual void buildButtons();

src/domain/UBItem.cpp

@@ -17,6 +17,15 @@
 
 #include "core/memcheck.h"
 
+#include "domain/UBGraphicsPixmapItem.h"
+#include "domain/UBGraphicsTextItem.h"
+#include "domain/UBGraphicsSvgItem.h"
+#include "domain/UBGraphicsMediaItem.h"
+#include "domain/UBGraphicsStrokesGroup.h"
+#include "domain/UBGraphicsGroupContainerItem.h"
+#include "domain/UBGraphicsWidgetItem.h"
+#include "tools/UBGraphicsCurtainItem.h"
+
 UBItem::UBItem()
     : mUuid(QUuid())
     , mRenderingQuality(UBItem::RenderingQualityNormal)
@@ -44,3 +53,37 @@ bool UBGraphicsItem::isRotatable(QGraphicsItem *item)
 {
     return item->data(UBGraphicsItemData::ItemRotatable).toBool();
 }
+
+UBGraphicsItemDelegate *UBGraphicsItem::Delegate(QGraphicsItem *pItem)
+{
+    UBGraphicsItemDelegate *result = 0;
+
+    switch (static_cast<int>(pItem->type())) {
+    case UBGraphicsPixmapItem::Type :
+        result = (static_cast<UBGraphicsPixmapItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsTextItem::Type :
+        result = (static_cast<UBGraphicsTextItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsSvgItem::Type :
+        result = (static_cast<UBGraphicsSvgItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsMediaItem::Type:
+        result = (static_cast<UBGraphicsMediaItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsStrokesGroup::Type :
+        result = (static_cast<UBGraphicsStrokesGroup*>(pItem))->Delegate();
+        break;
+    case UBGraphicsGroupContainerItem::Type :
+        result = (static_cast<UBGraphicsGroupContainerItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsWidgetItem::Type :
+        result = (static_cast<UBGraphicsWidgetItem*>(pItem))->Delegate();
+        break;
+    case UBGraphicsCurtainItem::Type :
+        result = (static_cast<UBGraphicsCurtainItem*>(pItem))->Delegate();
+        break;
+    }
+
+    return result;
+}

src/domain/UBItem.h

@@ -108,6 +108,7 @@ public:
     static bool isRotatable(QGraphicsItem *item);
     static bool isFlippable(QGraphicsItem *item);
 
+    static UBGraphicsItemDelegate *Delegate(QGraphicsItem *pItem);
     virtual UBGraphicsItemDelegate *Delegate() const  = 0;
 
     virtual void remove() = 0;

src/frameworks/UBCoreGraphicsScene.cpp

@@ -73,6 +73,7 @@ void UBCoreGraphicsScene::removeItem(QGraphicsItem* item, bool forceDelete)
     QGraphicsScene::removeItem(item);
     if (forceDelete)
     {
+        qDebug() << "force delete is " << forceDelete;
         deleteItem(item);
     }
     setModified(true);

src/frameworks/UBPlatformUtils.h

@@ -171,6 +171,7 @@ class UBPlatformUtils
         static int nKeyboardLayouts;
         static UBKeyboardLocale** keyboardLayouts;
 
+
 public:
         static void init();
         static void destroy();
@@ -192,6 +193,10 @@ public:
         static UBKeyboardLocale** getKeyboardLayouts(int& nCount);
         static QString urlFromClipboard();
         static QStringList availableTranslations();
+
+#ifdef Q_WS_MAC
+        static void SetMacLocaleByIdentifier(const QString& id);
+#endif
 };
 
 

src/frameworks/UBPlatformUtils_mac.mm

@@ -440,6 +440,9 @@ void UBPlatformUtils::initializeKeyboardLayouts()
     int count = CFArrayGetCount(kbds);
     QList<UBKeyboardLocale*> result;
 
+	qDebug() << "initializeKeyboardLayouts";
+	qDebug() << "Found system locales: " << count;
+
     for(int i=0; i<count; i++)
     {
         TISInputSourceRef keyLayoutRef =  (TISInputSourceRef)CFArrayGetValueAtIndex(kbds, i);
@@ -530,6 +533,8 @@ void UBPlatformUtils::initializeKeyboardLayouts()
         const QString resName = ":/images/flags/" + name + ".png";
         QIcon *iconLang = new QIcon(resName);
 
+		qDebug() << "Locale: " << ID << ", name: " << name;
+
         result.append(new UBKeyboardLocale(fullName, name, ID, iconLang, keybt));
     }
 
@@ -565,3 +570,28 @@ QString UBPlatformUtils::urlFromClipboard()
 */
     return qsRet;
 }
+
+
+void UBPlatformUtils::SetMacLocaleByIdentifier(const QString& id)
+{
+    NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
+
+    const char * strName = id.toAscii().data();
+
+    CFStringRef iName = CFStringCreateWithCString(NULL, strName, kCFStringEncodingMacRoman );
+
+    CFStringRef keys[] = { kTISPropertyInputSourceCategory, kTISPropertyInputSourceID };
+    CFStringRef values[] = { kTISCategoryKeyboardInputSource, iName };
+    CFDictionaryRef dict = CFDictionaryCreate(NULL, (const void **)keys, (const void **)values, 2, NULL, NULL);
+    CFArrayRef kbds = TISCreateInputSourceList(dict, true);
+    if (kbds!=NULL)
+    {
+        if (CFArrayGetCount(kbds)!=0)
+        {
+            TISInputSourceRef klRef =  (TISInputSourceRef)CFArrayGetValueAtIndex(kbds, 0);
+            if (klRef!=NULL)
+                TISSelectInputSource(klRef);
+        }
+    }
+    [pool drain];
+}

src/gui/UBKeyboardPalette.cpp

@@ -60,7 +60,10 @@ UBKeyboardPalette::UBKeyboardPalette(QWidget *parent)
     createCtrlButtons();
 
     nCurrentLocale = UBSettings::settings()->KeyboardLocale->get().toInt();
-    setInput(locales[nCurrentLocale]);
+	if (nCurrentLocale < 0 || nCurrentLocale >= nLocalesCount)
+		nCurrentLocale = 0;
+	if (locales!=NULL)
+	    setInput(locales[nCurrentLocale]);
 
     setContentsMargins( 22, 22, 22, 22 );
 

src/gui/UBKeyboardPalette_mac.cpp

@@ -57,22 +57,6 @@ void UBKeyboardPalette::createCtrlButtons()
         ctrlButtons[8] = new UBLocaleButton(this);
 }
 
-void SetMacLocaleByIdentifier(const QString& id)
-{
-	const char * strName = id.toAscii().data();
-	CFStringRef iName = CFStringCreateWithCString(NULL, strName, kCFStringEncodingMacRoman );
-
-	CFStringRef keys[] = { kTISPropertyInputSourceCategory, kTISPropertyInputSourceID };          
-	CFStringRef values[] = { kTISCategoryKeyboardInputSource, iName };          
-	CFDictionaryRef dict = CFDictionaryCreate(NULL, (const void **)keys, (const void **)values, 2, NULL, NULL);  
-	CFArrayRef kbds = TISCreateInputSourceList(dict, true);          
-	if (CFArrayGetCount(kbds)!=0)
-	{
-		TISInputSourceRef klRef =  (TISInputSourceRef)CFArrayGetValueAtIndex(kbds, 0);  
-		if (klRef!=NULL)
-			TISSelectInputSource(klRef);
-	}
-}
 
 
 void UBKeyboardPalette::checkLayout()
@@ -107,6 +91,6 @@ void UBKeyboardPalette::onActivated(bool)
 
 void UBKeyboardPalette::onLocaleChanged(UBKeyboardLocale* locale)
 {
-	SetMacLocaleByIdentifier(locale->id);
+    UBPlatformUtils::SetMacLocaleByIdentifier(locale->id);
 }