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

preferencesAboutTextFull
Aleksei Kanash 12 years ago
commit 807f83a606
  1. 2
      src/api/UBWidgetUniboardAPI.cpp
  2. 9
      src/board/UBBoardController.cpp
  3. 2
      src/desktop/UBDesktopAnnotationController.cpp
  4. 5
      src/domain/UBGraphicsGroupContainerItem.cpp
  5. 17
      src/domain/UBGraphicsItemDelegate.cpp
  6. 1
      src/domain/UBGraphicsItemDelegate.h
  7. 161
      src/domain/UBGraphicsScene.cpp
  8. 12
      src/domain/UBGraphicsScene.h
  9. 48
      src/domain/UBGraphicsStrokesGroup.cpp
  10. 8
      src/domain/UBGraphicsStrokesGroup.h
  11. 5
      src/domain/UBGraphicsTextItemDelegate.cpp
  12. 1
      src/domain/UBGraphicsTextItemDelegate.h
  13. 43
      src/domain/UBItem.cpp
  14. 1
      src/domain/UBItem.h
  15. 1
      src/frameworks/UBCoreGraphicsScene.cpp
  16. 5
      src/frameworks/UBPlatformUtils.h
  17. 30
      src/frameworks/UBPlatformUtils_mac.mm
  18. 5
      src/gui/UBKeyboardPalette.cpp
  19. 18
      src/gui/UBKeyboardPalette_mac.cpp

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

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

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

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

@ -387,9 +387,22 @@ void UBGraphicsItemDelegate::remove(bool canUndo)
UBGraphicsScene* scene = dynamic_cast<UBGraphicsScene*>(mDelegated->scene()); UBGraphicsScene* scene = dynamic_cast<UBGraphicsScene*>(mDelegated->scene());
if (scene) if (scene)
{ {
foreach(DelegateButton* button, mButtons) // bool shownOnDisplay = mDelegated->data(UBGraphicsItemData::ItemLayerType).toInt() != UBItemLayerType::Control;
scene->removeItem(button); // 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); scene->removeItem(mFrame);
/* this is performed because when removing delegated from scene while it contains flash content, segfault happens because of QGraphicsScene::removeItem() */ /* this is performed because when removing delegated from scene while it contains flash content, segfault happens because of QGraphicsScene::removeItem() */

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

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

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

@ -32,6 +32,54 @@ void UBGraphicsStrokesGroup::setUuid(const QUuid &pUuid)
UBItem::setUuid(pUuid); UBItem::setUuid(pUuid);
setData(UBGraphicsItemData::ItemUuid, QVariant(pUuid)); //store item uuid inside the QGraphicsItem to fast operations with Items on the scene 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) void UBGraphicsStrokesGroup::mousePressEvent(QGraphicsSceneMouseEvent *event)
{ {

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

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

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

@ -17,6 +17,15 @@
#include "core/memcheck.h" #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() UBItem::UBItem()
: mUuid(QUuid()) : mUuid(QUuid())
, mRenderingQuality(UBItem::RenderingQualityNormal) , mRenderingQuality(UBItem::RenderingQualityNormal)
@ -44,3 +53,37 @@ bool UBGraphicsItem::isRotatable(QGraphicsItem *item)
{ {
return item->data(UBGraphicsItemData::ItemRotatable).toBool(); 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;
}

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

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

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

@ -440,6 +440,9 @@ void UBPlatformUtils::initializeKeyboardLayouts()
int count = CFArrayGetCount(kbds); int count = CFArrayGetCount(kbds);
QList<UBKeyboardLocale*> result; QList<UBKeyboardLocale*> result;
qDebug() << "initializeKeyboardLayouts";
qDebug() << "Found system locales: " << count;
for(int i=0; i<count; i++) for(int i=0; i<count; i++)
{ {
TISInputSourceRef keyLayoutRef = (TISInputSourceRef)CFArrayGetValueAtIndex(kbds, i); TISInputSourceRef keyLayoutRef = (TISInputSourceRef)CFArrayGetValueAtIndex(kbds, i);
@ -530,6 +533,8 @@ void UBPlatformUtils::initializeKeyboardLayouts()
const QString resName = ":/images/flags/" + name + ".png"; const QString resName = ":/images/flags/" + name + ".png";
QIcon *iconLang = new QIcon(resName); QIcon *iconLang = new QIcon(resName);
qDebug() << "Locale: " << ID << ", name: " << name;
result.append(new UBKeyboardLocale(fullName, name, ID, iconLang, keybt)); result.append(new UBKeyboardLocale(fullName, name, ID, iconLang, keybt));
} }
@ -565,3 +570,28 @@ QString UBPlatformUtils::urlFromClipboard()
*/ */
return qsRet; 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];
}

@ -60,7 +60,10 @@ UBKeyboardPalette::UBKeyboardPalette(QWidget *parent)
createCtrlButtons(); createCtrlButtons();
nCurrentLocale = UBSettings::settings()->KeyboardLocale->get().toInt(); 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 ); setContentsMargins( 22, 22, 22, 22 );

@ -57,22 +57,6 @@ void UBKeyboardPalette::createCtrlButtons()
ctrlButtons[8] = new UBLocaleButton(this); 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() void UBKeyboardPalette::checkLayout()
@ -107,6 +91,6 @@ void UBKeyboardPalette::onActivated(bool)
void UBKeyboardPalette::onLocaleChanged(UBKeyboardLocale* locale) void UBKeyboardPalette::onLocaleChanged(UBKeyboardLocale* locale)
{ {
SetMacLocaleByIdentifier(locale->id); UBPlatformUtils::SetMacLocaleByIdentifier(locale->id);
} }

Loading…
Cancel
Save