aji/ScreenTranslator
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Code formatting with uncrustify.

Browse Source
This commit is contained in:
Gres 2015-09-22 21:41:08 +03:00
parent f97082d1ed
commit 9007379242
27 changed files with 2114 additions and 669 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

123
GlobalActionHelper.cpp
View File

@ -5,88 +5,82 @@
#include <QDebug> #include <QDebug>
#include <QApplication> #include <QApplication>
QHash<QPair<quint32, quint32>, QAction*> GlobalActionHelper::actions_; QHash<QPair<quint32, quint32>, QAction *> GlobalActionHelper::actions_;
bool GlobalActionHelper::nativeEventFilter(const QByteArray& eventType, bool GlobalActionHelper::nativeEventFilter (const QByteArray &eventType,
void* message, long* result) void *message, long *result) {
{
Q_UNUSED (eventType); Q_UNUSED (eventType);
Q_UNUSED (result); Q_UNUSED (result);
MSG* msg = static_cast<MSG*>(message); MSG *msg = static_cast<MSG *>(message);
if (msg->message == WM_HOTKEY) if (msg->message == WM_HOTKEY) {
{ const quint32 keycode = HIWORD (msg->lParam);
const quint32 keycode = HIWORD(msg->lParam); const quint32 modifiers = LOWORD (msg->lParam);
const quint32 modifiers = LOWORD(msg->lParam); QAction *action = actions_.value (qMakePair (keycode, modifiers));
QAction* action = actions_.value (qMakePair (keycode, modifiers));
Q_CHECK_PTR (action); Q_CHECK_PTR (action);
action->activate (QAction::Trigger); action->activate (QAction::Trigger);
} }
return false; return false;
} }
void GlobalActionHelper::init() void GlobalActionHelper::init () {
{
qApp->installNativeEventFilter (new GlobalActionHelper); qApp->installNativeEventFilter (new GlobalActionHelper);
} }
bool GlobalActionHelper::makeGlobal(QAction* action) bool GlobalActionHelper::makeGlobal (QAction *action) {
{
QKeySequence hotKey = action->shortcut (); QKeySequence hotKey = action->shortcut ();
if (hotKey.isEmpty ()) if (hotKey.isEmpty ()) {
{
return true; return true;
} }
Qt::KeyboardModifiers allMods = Qt::ShiftModifier | Qt::ControlModifier | Qt::KeyboardModifiers allMods = Qt::ShiftModifier | Qt::ControlModifier |
Qt::AltModifier | Qt::MetaModifier; Qt::AltModifier | Qt::MetaModifier;
Qt::Key key = hotKey.isEmpty() ? Qt::Key key = hotKey.isEmpty () ?
Qt::Key(0) : Qt::Key (0) :
Qt::Key((hotKey[0] ^ allMods) & hotKey[0]); Qt::Key ((hotKey[0] ^ allMods) & hotKey[0]);
Qt::KeyboardModifiers mods = hotKey.isEmpty() ? Qt::KeyboardModifiers mods = hotKey.isEmpty () ?
Qt::KeyboardModifiers(0) : Qt::KeyboardModifiers (0) :
Qt::KeyboardModifiers(hotKey[0] & allMods); Qt::KeyboardModifiers (hotKey[0] & allMods);
const quint32 nativeKey = nativeKeycode(key); const quint32 nativeKey = nativeKeycode (key);
const quint32 nativeMods = nativeModifiers(mods); const quint32 nativeMods = nativeModifiers (mods);
const bool res = registerHotKey(nativeKey, nativeMods); const bool res = registerHotKey (nativeKey, nativeMods);
if (res) if (res) {
actions_.insert (qMakePair(nativeKey, nativeMods), action); actions_.insert (qMakePair (nativeKey, nativeMods), action);
else }
qWarning() << "Failed to register global hotkey:" << hotKey.toString(); else {
qWarning () << "Failed to register global hotkey:" << hotKey.toString ();
}
return res; return res;
} }
bool GlobalActionHelper::removeGlobal(QAction *action) bool GlobalActionHelper::removeGlobal (QAction *action) {
{
QKeySequence hotKey = action->shortcut (); QKeySequence hotKey = action->shortcut ();
if (hotKey.isEmpty ()) if (hotKey.isEmpty ()) {
{
return true; return true;
} }
Qt::KeyboardModifiers allMods = Qt::ShiftModifier | Qt::ControlModifier | Qt::KeyboardModifiers allMods = Qt::ShiftModifier | Qt::ControlModifier |
Qt::AltModifier | Qt::MetaModifier; Qt::AltModifier | Qt::MetaModifier;
Qt::Key key = hotKey.isEmpty() ? Qt::Key key = hotKey.isEmpty () ?
Qt::Key(0) : Qt::Key (0) :
Qt::Key((hotKey[0] ^ allMods) & hotKey[0]); Qt::Key ((hotKey[0] ^ allMods) & hotKey[0]);
Qt::KeyboardModifiers mods = hotKey.isEmpty() ? Qt::KeyboardModifiers mods = hotKey.isEmpty () ?
Qt::KeyboardModifiers(0) : Qt::KeyboardModifiers (0) :
Qt::KeyboardModifiers(hotKey[0] & allMods); Qt::KeyboardModifiers (hotKey[0] & allMods);
const quint32 nativeKey = nativeKeycode(key); const quint32 nativeKey = nativeKeycode (key);
const quint32 nativeMods = nativeModifiers(mods); const quint32 nativeMods = nativeModifiers (mods);
if (!actions_.contains (qMakePair(nativeKey, nativeMods))) if (!actions_.contains (qMakePair (nativeKey, nativeMods))) {
{
return true; return true;
} }
const bool res = unregisterHotKey(nativeKey, nativeMods); const bool res = unregisterHotKey (nativeKey, nativeMods);
if (res) if (res) {
actions_.remove (qMakePair(nativeKey, nativeMods)); actions_.remove (qMakePair (nativeKey, nativeMods));
else }
qWarning() << "Failed to unregister global hotkey:" << hotKey.toString(); else {
qWarning () << "Failed to unregister global hotkey:" << hotKey.toString ();
}
return res; return res;
} }
quint32 GlobalActionHelper::nativeKeycode(Qt::Key key) quint32 GlobalActionHelper::nativeKeycode (Qt::Key key) {
{ switch (key) {
switch (key)
{
case Qt::Key_Escape: case Qt::Key_Escape:
return VK_ESCAPE; return VK_ESCAPE;
case Qt::Key_Tab: case Qt::Key_Tab:
@ -248,29 +242,30 @@ quint32 GlobalActionHelper::nativeKeycode(Qt::Key key)
} }
} }
quint32 GlobalActionHelper::nativeModifiers(Qt::KeyboardModifiers modifiers) quint32 GlobalActionHelper::nativeModifiers (Qt::KeyboardModifiers modifiers) {
{
// MOD_ALT, MOD_CONTROL, (MOD_KEYUP), MOD_SHIFT, MOD_WIN // MOD_ALT, MOD_CONTROL, (MOD_KEYUP), MOD_SHIFT, MOD_WIN
quint32 native = 0; quint32 native = 0;
if (modifiers & Qt::ShiftModifier) if (modifiers & Qt::ShiftModifier) {
native |= MOD_SHIFT; native |= MOD_SHIFT;
if (modifiers & Qt::ControlModifier) }
if (modifiers & Qt::ControlModifier) {
native |= MOD_CONTROL; native |= MOD_CONTROL;
if (modifiers & Qt::AltModifier) }
if (modifiers & Qt::AltModifier) {
native |= MOD_ALT; native |= MOD_ALT;
if (modifiers & Qt::MetaModifier) }
if (modifiers & Qt::MetaModifier) {
native |= MOD_WIN; native |= MOD_WIN;
}
//if (modifiers & Qt::KeypadModifier) //if (modifiers & Qt::KeypadModifier)
//if (modifiers & Qt::GroupSwitchModifier) //if (modifiers & Qt::GroupSwitchModifier)
return native; return native;
} }
bool GlobalActionHelper::registerHotKey(quint32 nativeKey, quint32 nativeMods) bool GlobalActionHelper::registerHotKey (quint32 nativeKey, quint32 nativeMods) {
{ return RegisterHotKey (0, nativeMods ^ nativeKey, nativeMods, nativeKey);
return RegisterHotKey(0, nativeMods ^ nativeKey, nativeMods, nativeKey);
} }
bool GlobalActionHelper::unregisterHotKey(quint32 nativeKey, quint32 nativeMods) bool GlobalActionHelper::unregisterHotKey (quint32 nativeKey, quint32 nativeMods) {
{ return UnregisterHotKey (0, nativeMods ^ nativeKey);
return UnregisterHotKey(0, nativeMods ^ nativeKey);
} }

9
GlobalActionHelper.h
View File

@ -6,18 +6,17 @@
#include <QAbstractNativeEventFilter> #include <QAbstractNativeEventFilter>
#include <QAction> #include <QAction>
class GlobalActionHelper : public QAbstractNativeEventFilter class GlobalActionHelper : public QAbstractNativeEventFilter {
{
public: public:
bool nativeEventFilter (const QByteArray &eventType, void *message, bool nativeEventFilter (const QByteArray &eventType, void *message,
long *result); long *result);
static void init (); static void init ();
static bool makeGlobal (QAction* action); static bool makeGlobal (QAction *action);
static bool removeGlobal (QAction* action); static bool removeGlobal (QAction *action);
private: private:
static QHash<QPair<quint32, quint32>, QAction*> actions_; static QHash<QPair<quint32, quint32>, QAction *> actions_;
static quint32 nativeKeycode (Qt::Key key); static quint32 nativeKeycode (Qt::Key key);
static quint32 nativeModifiers (Qt::KeyboardModifiers modifiers); static quint32 nativeModifiers (Qt::KeyboardModifiers modifiers);

53
GoogleWebTranslator.cpp
View File

@ -9,85 +9,84 @@
#include "Settings.h" #include "Settings.h"
#include "StAssert.h" #include "StAssert.h"
GoogleWebTranslator::GoogleWebTranslator() GoogleWebTranslator::GoogleWebTranslator ()
: QObject (), view_ (new QWebView), : QObject (), view_ (new QWebView),
isLoadFinished_ (true), isTranslationFinished_ (false) { isLoadFinished_ (true), isTranslationFinished_ (false) {
view_->settings()->setAttribute(QWebSettings::AutoLoadImages, false); view_->settings ()->setAttribute (QWebSettings::AutoLoadImages, false);
connect (view_, SIGNAL (loadStarted()), this, SLOT (loadStarted())); connect (view_, SIGNAL (loadStarted ()), this, SLOT (loadStarted ()));
connect (view_, SIGNAL (loadFinished(bool)), this, SLOT (loadFinished(bool))); connect (view_, SIGNAL (loadFinished (bool)), this, SLOT (loadFinished (bool)));
connect (view_->page()->networkAccessManager(), SIGNAL (finished(QNetworkReply*)), connect (view_->page ()->networkAccessManager (), SIGNAL (finished (QNetworkReply *)),
this, SLOT(replyFinished(QNetworkReply*))); this, SLOT (replyFinished (QNetworkReply *)));
applySettings (); applySettings ();
} }
GoogleWebTranslator::~GoogleWebTranslator() { GoogleWebTranslator::~GoogleWebTranslator () {
delete view_; delete view_;
} }
void GoogleWebTranslator::translate(ProcessingItem item) { void GoogleWebTranslator::translate (ProcessingItem item) {
queue_.push_back (item); queue_.push_back (item);
if (isLoadFinished_) { if (isLoadFinished_) {
load (item); load (item);
} }
} }
void GoogleWebTranslator::applySettings(){ void GoogleWebTranslator::applySettings () {
QSettings settings; QSettings settings;
settings.beginGroup (settings_names::translationGroup); settings.beginGroup (settings_names::translationGroup);
translationLanguage_ = settings.value (settings_names::translationLanguage, translationLanguage_ = settings.value (settings_names::translationLanguage,
settings_values::translationLanguage).toString (); settings_values::translationLanguage).toString ();
} }
void GoogleWebTranslator::loadStarted() { void GoogleWebTranslator::loadStarted () {
isLoadFinished_ = false; isLoadFinished_ = false;
isTranslationFinished_ = false; isTranslationFinished_ = false;
} }
void GoogleWebTranslator::loadFinished(bool ok) { void GoogleWebTranslator::loadFinished (bool ok) {
isLoadFinished_ = true; isLoadFinished_ = true;
if (ok && !isTranslationFinished_) { if (ok && !isTranslationFinished_) {
return; return;
} }
if (!queue_.isEmpty()) { if (!queue_.isEmpty ()) {
ProcessingItem item = queue_.front(); ProcessingItem item = queue_.front ();
queue_.pop_front(); queue_.pop_front ();
if (ok) { if (ok) {
QWebElementCollection result = view_->page()->mainFrame()->findAllElements("#result_box > span"); QWebElementCollection result = view_->page ()->mainFrame ()->findAllElements ("#result_box > span");
item.translated = ""; item.translated = "";
foreach (const QWebElement& element, result) { foreach (const QWebElement &element, result) {
item.translated += element.toInnerXml() + " "; item.translated += element.toInnerXml () + " ";
} }
emit translated(item, !item.translated.isEmpty()); emit translated (item, !item.translated.isEmpty ());
} }
else { else {
emit translated (item, false); emit translated (item, false);
} }
} }
if (!queue_.isEmpty()) { if (!queue_.isEmpty ()) {
load (queue_.front()); load (queue_.front ());
} }
} }
void GoogleWebTranslator::replyFinished(QNetworkReply *reply) void GoogleWebTranslator::replyFinished (QNetworkReply *reply) {
{ if (reply->url ().toString ().contains ("/translate_a/single")) {
if (reply->url().toString().contains ("/translate_a/single")) {
isTranslationFinished_ = true; isTranslationFinished_ = true;
if (isLoadFinished_) { if (isLoadFinished_) {
QTimer::singleShot(2000, this, SLOT(loadFinished())); QTimer::singleShot (2000, this, SLOT (loadFinished ()));
} }
} }
} }
void GoogleWebTranslator::load(const ProcessingItem &item) { void GoogleWebTranslator::load (const ProcessingItem &item) {
ST_ASSERT (!item.recognized.isEmpty ()); ST_ASSERT (!item.recognized.isEmpty ());
if (translationLanguage_.isEmpty ()) { if (translationLanguage_.isEmpty ()) {
emit error (tr ("Неверные парметры для перевода.")); emit error (tr ("Неверные парметры для перевода."));
return; return;
} }
QUrl url (QString ("https://translate.google.com/#auto/%1/%2").arg(translationLanguage_, item.recognized)); QUrl url (QString ("https://translate.google.com/#auto/%1/%2").arg (translationLanguage_, item.recognized));
view_->setUrl(url); view_->setUrl (url);
} }

14
GoogleWebTranslator.h
View File

@ -9,12 +9,12 @@ class QWebView;
class QUrl; class QUrl;
class QNetworkReply; class QNetworkReply;
class GoogleWebTranslator : public QObject class GoogleWebTranslator : public QObject {
{
Q_OBJECT Q_OBJECT
public: public:
GoogleWebTranslator(); GoogleWebTranslator ();
~GoogleWebTranslator(); ~GoogleWebTranslator ();
signals: signals:
void translated (ProcessingItem item, bool success); void translated (ProcessingItem item, bool success);
@ -26,11 +26,11 @@ class GoogleWebTranslator : public QObject
private slots: private slots:
void loadStarted (); void loadStarted ();
void loadFinished(bool ok=true); void loadFinished (bool ok = true);
void replyFinished(QNetworkReply * reply); void replyFinished (QNetworkReply *reply);
private: private:
void load (const ProcessingItem& item); void load (const ProcessingItem &item);
private: private:
QVector<ProcessingItem> queue_; QVector<ProcessingItem> queue_;

121
ImageProcessing.cpp
View File

@ -8,121 +8,120 @@
#include "StAssert.h" #include "StAssert.h"
#ifdef WIN32 #ifdef WIN32
#include <windows.h> # include <windows.h>
qint64 getFreeMemory () qint64 getFreeMemory () {
{
MEMORYSTATUSEX statex; MEMORYSTATUSEX statex;
statex.dwLength = sizeof (statex); statex.dwLength = sizeof (statex);
if (GlobalMemoryStatusEx (&statex)) if (GlobalMemoryStatusEx (&statex)) {
{
return statex.ullAvailPhys; return statex.ullAvailPhys;
} }
return -1; return -1;
} }
#endif #endif
Pix *convertImage(const QImage& image) Pix * convertImage (const QImage &image) {
{
PIX *pix; PIX *pix;
QImage swapped = image.rgbSwapped(); QImage swapped = image.rgbSwapped ();
int width = swapped.width(); int width = swapped.width ();
int height = swapped.height(); int height = swapped.height ();
int depth = swapped.depth(); int depth = swapped.depth ();
int wpl = swapped.bytesPerLine() / 4; int wpl = swapped.bytesPerLine () / 4;
pix = pixCreate(width, height, depth); pix = pixCreate (width, height, depth);
pixSetWpl(pix, wpl); pixSetWpl (pix, wpl);
pixSetColormap(pix, NULL); pixSetColormap (pix, NULL);
l_uint32 *outData = pix->data; l_uint32 *outData = pix->data;
for (int y = 0; y < height; y++) for (int y = 0; y < height; y++) {
{
l_uint32 *lines = outData + y * wpl; l_uint32 *lines = outData + y * wpl;
QByteArray a((const char*)swapped.scanLine(y), swapped.bytesPerLine()); QByteArray a ((const char *)swapped.scanLine (y), swapped.bytesPerLine ());
for (int j = 0; j < a.size(); j++) for (int j = 0; j < a.size (); j++) {
{
*((l_uint8 *)lines + j) = a[j]; *((l_uint8 *)lines + j) = a[j];
} }
} }
const qreal toDPM = 1.0 / 0.0254; const qreal toDPM = 1.0 / 0.0254;
int resolutionX = swapped.dotsPerMeterX() / toDPM; int resolutionX = swapped.dotsPerMeterX () / toDPM;
int resolutionY = swapped.dotsPerMeterY() / toDPM; int resolutionY = swapped.dotsPerMeterY () / toDPM;
if (resolutionX < 300) resolutionX = 300; if (resolutionX < 300) {
if (resolutionY < 300) resolutionY = 300; resolutionX = 300;
pixSetResolution(pix, resolutionX, resolutionY); }
if (resolutionY < 300) {
resolutionY = 300;
}
pixSetResolution (pix, resolutionX, resolutionY);
return pixEndianByteSwapNew(pix); return pixEndianByteSwapNew (pix);
} }
QImage convertImage(Pix &image) QImage convertImage (Pix &image) {
{ int width = pixGetWidth (&image);
int width = pixGetWidth(&image); int height = pixGetHeight (&image);
int height = pixGetHeight(&image); int depth = pixGetDepth (&image);
int depth = pixGetDepth(&image); int bytesPerLine = pixGetWpl (&image) * 4;
int bytesPerLine = pixGetWpl(&image) * 4; l_uint32 *datas = pixGetData (pixEndianByteSwapNew (&image));
l_uint32 * datas = pixGetData(pixEndianByteSwapNew(&image));
QImage::Format format; QImage::Format format;
if (depth == 1) if (depth == 1) {
format = QImage::Format_Mono; format = QImage::Format_Mono;
else if (depth == 8) }
else if (depth == 8) {
format = QImage::Format_Indexed8; format = QImage::Format_Indexed8;
else }
else {
format = QImage::Format_RGB32; format = QImage::Format_RGB32;
}
QImage result((uchar*)datas, width, height, bytesPerLine, format); QImage result ((uchar *)datas, width, height, bytesPerLine, format);
// Set resolution // Set resolution
l_int32 xres, yres; l_int32 xres, yres;
pixGetResolution(&image, &xres, &yres); pixGetResolution (&image, &xres, &yres);
const qreal toDPM = 1.0 / 0.0254; const qreal toDPM = 1.0 / 0.0254;
result.setDotsPerMeterX(xres * toDPM); result.setDotsPerMeterX (xres * toDPM);
result.setDotsPerMeterY(yres * toDPM); result.setDotsPerMeterY (yres * toDPM);
// Handle pallete // Handle pallete
QVector<QRgb> _bwCT; QVector<QRgb> _bwCT;
_bwCT.append(qRgb(255,255,255)); _bwCT.append (qRgb (255,255,255));
_bwCT.append(qRgb(0,0,0)); _bwCT.append (qRgb (0,0,0));
QVector<QRgb> _grayscaleCT(256); QVector<QRgb> _grayscaleCT (256);
for (int i = 0; i < 256; i++) { for (int i = 0; i < 256; i++) {
_grayscaleCT.append(qRgb(i, i, i)); _grayscaleCT.append (qRgb (i, i, i));
} }
switch (depth) { switch (depth) {
case 1: case 1:
result.setColorTable(_bwCT); result.setColorTable (_bwCT);
break; break;
case 8: case 8:
result.setColorTable(_grayscaleCT); result.setColorTable (_grayscaleCT);
break; break;
default: default:
result.setColorTable(_grayscaleCT); result.setColorTable (_grayscaleCT);
} }
if (result.isNull()) { if (result.isNull ()) {
static QImage none(0,0,QImage::Format_Invalid); static QImage none (0,0,QImage::Format_Invalid);
qDebug("Invalid format!!!\n"); qDebug ("Invalid format!!!\n");
return none; return none;
} }
return result.rgbSwapped(); return result.rgbSwapped ();
} }
Pix *prepareImage(const QImage &image, int preferredScale) Pix * prepareImage (const QImage &image, int preferredScale) {
{ Pix *pix = convertImage (image);
Pix* pix = convertImage (image);
ST_ASSERT (pix != NULL); ST_ASSERT (pix != NULL);
Pix* gray = pixConvertRGBToGray (pix, 0.0, 0.0, 0.0); Pix *gray = pixConvertRGBToGray (pix, 0.0, 0.0, 0.0);
ST_ASSERT (gray != NULL); ST_ASSERT (gray != NULL);
pixDestroy (&pix); pixDestroy (&pix);
Pix* scaled = gray; Pix *scaled = gray;
if (preferredScale > 0) if (preferredScale > 0) {
{
float maxScaleX = MAX_INT16 / double (gray->w); float maxScaleX = MAX_INT16 / double (gray->w);
float scaleX = std::min (float (preferredScale), maxScaleX); float scaleX = std::min (float (preferredScale), maxScaleX);
float maxScaleY = MAX_INT16 / double (gray->h); float maxScaleY = MAX_INT16 / double (gray->h);
@ -139,14 +138,12 @@ Pix *prepareImage(const QImage &image, int preferredScale)
scaled = pixScale (gray, scale, scale); scaled = pixScale (gray, scale, scale);
} }
ST_ASSERT (scaled != NULL); ST_ASSERT (scaled != NULL);
if (scaled != gray) if (scaled != gray) {
{
pixDestroy (&gray); pixDestroy (&gray);
} }
return scaled; return scaled;
} }
void cleanupImage(Pix **image) void cleanupImage (Pix **image) {
{
pixDestroy (image); pixDestroy (image);
} }

8
ImageProcessing.h
View File

@ -6,13 +6,13 @@
class Pix; class Pix;
//! Convert QImage to Leptonica's PIX. //! Convert QImage to Leptonica's PIX.
Pix* convertImage(const QImage& image); Pix * convertImage (const QImage &image);
//! Convert Leptonica's PIX to QImage. //! Convert Leptonica's PIX to QImage.
QImage convertImage(Pix &image); QImage convertImage (Pix &image);
//! Propare image for OCR. //! Propare image for OCR.
Pix* prepareImage (const QImage& image, int preferredScale); Pix * prepareImage (const QImage &image, int preferredScale);
//! Free allocated resources for image. //! Free allocated resources for image.
void cleanupImage (Pix** image); void cleanupImage (Pix **image);
#endif // IMAGEPROCESSING_H #endif // IMAGEPROCESSING_H

305
LanguageHelper.cpp
View File

@ -4,108 +4,89 @@
#include "LanguageHelper.h" #include "LanguageHelper.h"
#include "Settings.h" #include "Settings.h"
LanguageHelper::LanguageHelper() LanguageHelper::LanguageHelper () {
{
init (); init ();
} }
QStringList LanguageHelper::availableOcrLanguagesUi() const QStringList LanguageHelper::availableOcrLanguagesUi () const {
{
QStringList uiItems; QStringList uiItems;
foreach (const QString& item, availableOcrLanguages_) foreach (const QString &item, availableOcrLanguages_) {
{
uiItems << ocrCodeToUi (item); uiItems << ocrCodeToUi (item);
} }
uiItems.sort (); uiItems.sort ();
return uiItems; return uiItems;
} }
const QStringList &LanguageHelper::availableOcrLanguages() const const QStringList &LanguageHelper::availableOcrLanguages () const {
{
return availableOcrLanguages_; return availableOcrLanguages_;
} }
QStringList LanguageHelper::availableOcrLanguages(const QString &path) const QStringList LanguageHelper::availableOcrLanguages (const QString &path) const {
{
QDir dir (path + "/tessdata/"); QDir dir (path + "/tessdata/");
if (!dir.exists ()) if (!dir.exists ()) {
{
return QStringList (); return QStringList ();
} }
QStringList items; QStringList items;
QStringList files = dir.entryList (QStringList () << "*.traineddata", QDir::Files); QStringList files = dir.entryList (QStringList () << "*.traineddata", QDir::Files);
foreach (const QString& file, files) foreach (const QString &file, files) {
{
QString lang = file.left (file.indexOf (".")); QString lang = file.left (file.indexOf ("."));
items << lang; items << lang;
} }
return items; return items;
} }
QStringList LanguageHelper::availableOcrLanguagesUi(const QString &path) const QStringList LanguageHelper::availableOcrLanguagesUi (const QString &path) const {
{
QStringList uiItems, items; QStringList uiItems, items;
items = availableOcrLanguages (path); items = availableOcrLanguages (path);
foreach (const QString& item, items) foreach (const QString &item, items) {
{
uiItems << ocrCodeToUi (item); uiItems << ocrCodeToUi (item);
} }
uiItems.sort (); uiItems.sort ();
return uiItems; return uiItems;
} }
QStringList LanguageHelper::translateLanguagesUi() const QStringList LanguageHelper::translateLanguagesUi () const {
{
QStringList uiItems = translateLanguages_.keys (); QStringList uiItems = translateLanguages_.keys ();
uiItems.sort (); uiItems.sort ();
return uiItems; return uiItems;
} }
QStringList LanguageHelper::translateLanguages() const QStringList LanguageHelper::translateLanguages () const {
{
return translateLanguages_.values (); return translateLanguages_.values ();
} }
QString LanguageHelper::translateCodeToUi(const QString &text) const QString LanguageHelper::translateCodeToUi (const QString &text) const {
{
return translateLanguages_.key (text, text); return translateLanguages_.key (text, text);
} }
QString LanguageHelper::translateUiToCode(const QString &text) const QString LanguageHelper::translateUiToCode (const QString &text) const {
{
return translateLanguages_.value (text, text); return translateLanguages_.value (text, text);
} }
QString LanguageHelper::ocrCodeToUi(const QString &text) const QString LanguageHelper::ocrCodeToUi (const QString &text) const {
{
return ocrLanguages_.key (text, text); return ocrLanguages_.key (text, text);
} }
QString LanguageHelper::ocrUiToCode(const QString &text) const QString LanguageHelper::ocrUiToCode (const QString &text) const {
{
return ocrLanguages_.value (text, text); return ocrLanguages_.value (text, text);
} }
QString LanguageHelper::translateForOcrCode(const QString &text) const QString LanguageHelper::translateForOcrCode (const QString &text) const {
{
QString ocrUi = ocrUiToCode (text); QString ocrUi = ocrUiToCode (text);
QString translate = translateCodeToUi (ocrUi); QString translate = translateCodeToUi (ocrUi);
if (translate == ocrUi) if (translate == ocrUi) {
{
translate = "auto"; translate = "auto";
} }
return translate; return translate;
} }
void LanguageHelper::init() void LanguageHelper::init () {
{
initOcrLanguages (); initOcrLanguages ();
initTranslateLanguages (); initTranslateLanguages ();
updateAvailableOcrLanguages (); updateAvailableOcrLanguages ();
} }
void LanguageHelper::updateAvailableOcrLanguages() void LanguageHelper::updateAvailableOcrLanguages () {
{
availableOcrLanguages_.clear (); availableOcrLanguages_.clear ();
QSettings settings; QSettings settings;
settings.beginGroup (settings_names::recogntionGroup); settings.beginGroup (settings_names::recogntionGroup);
@ -114,131 +95,129 @@ void LanguageHelper::updateAvailableOcrLanguages()
availableOcrLanguages_ = availableOcrLanguages (tessDataPlace); availableOcrLanguages_ = availableOcrLanguages (tessDataPlace);
} }
void LanguageHelper::initTranslateLanguages() void LanguageHelper::initTranslateLanguages () {
{ translateLanguages_.insert (QObject::tr ("Afrikaans"),"af");
translateLanguages_.insert(QObject::tr("Afrikaans"),"af"); translateLanguages_.insert (QObject::tr ("Albanian"),"sq");
translateLanguages_.insert(QObject::tr("Albanian"),"sq"); translateLanguages_.insert (QObject::tr ("Arabic"),"ar");
translateLanguages_.insert(QObject::tr("Arabic"),"ar"); translateLanguages_.insert (QObject::tr ("Armenian"),"hy");
translateLanguages_.insert(QObject::tr("Armenian"),"hy"); translateLanguages_.insert (QObject::tr ("Azerbaijani"),"az");
translateLanguages_.insert(QObject::tr("Azerbaijani"),"az"); translateLanguages_.insert (QObject::tr ("Basque"),"eu");
translateLanguages_.insert(QObject::tr("Basque"),"eu"); translateLanguages_.insert (QObject::tr ("Belarusian"),"be");
translateLanguages_.insert(QObject::tr("Belarusian"),"be"); translateLanguages_.insert (QObject::tr ("Bulgarian"),"bg");
translateLanguages_.insert(QObject::tr("Bulgarian"),"bg"); translateLanguages_.insert (QObject::tr ("Catalan"),"ca");
translateLanguages_.insert(QObject::tr("Catalan"),"ca"); translateLanguages_.insert (QObject::tr ("Chinese (Simplified)"),"zh-CN");
translateLanguages_.insert(QObject::tr("Chinese (Simplified)"),"zh-CN"); translateLanguages_.insert (QObject::tr ("Chinese (Traditional)"),"zh-TW");
translateLanguages_.insert(QObject::tr("Chinese (Traditional)"),"zh-TW"); translateLanguages_.insert (QObject::tr ("Croatian"),"hr");
translateLanguages_.insert(QObject::tr("Croatian"),"hr"); translateLanguages_.insert (QObject::tr ("Czech"),"cs");
translateLanguages_.insert(QObject::tr("Czech"),"cs"); translateLanguages_.insert (QObject::tr ("Danish"),"da");
translateLanguages_.insert(QObject::tr("Danish"),"da"); translateLanguages_.insert (QObject::tr ("Dutch"),"nl");
translateLanguages_.insert(QObject::tr("Dutch"),"nl"); translateLanguages_.insert (QObject::tr ("English"),"en");
translateLanguages_.insert(QObject::tr("English"),"en"); translateLanguages_.insert (QObject::tr ("Estonian"),"et");
translateLanguages_.insert(QObject::tr("Estonian"),"et"); translateLanguages_.insert (QObject::tr ("Filipino"),"tl");
translateLanguages_.insert(QObject::tr("Filipino"),"tl"); translateLanguages_.insert (QObject::tr ("Finnish"),"fi");
translateLanguages_.insert(QObject::tr("Finnish"),"fi"); translateLanguages_.insert (QObject::tr ("French"),"fr");
translateLanguages_.insert(QObject::tr("French"),"fr"); translateLanguages_.insert (QObject::tr ("Galician"),"gl");
translateLanguages_.insert(QObject::tr("Galician"),"gl"); translateLanguages_.insert (QObject::tr ("Georgian"),"ka");
translateLanguages_.insert(QObject::tr("Georgian"),"ka"); translateLanguages_.insert (QObject::tr ("German"),"de");
translateLanguages_.insert(QObject::tr("German"),"de"); translateLanguages_.insert (QObject::tr ("Greek"),"el");
translateLanguages_.insert(QObject::tr("Greek"),"el"); translateLanguages_.insert (QObject::tr ("Haitian Creole"),"ht");
translateLanguages_.insert(QObject::tr("Haitian Creole"),"ht"); translateLanguages_.insert (QObject::tr ("Hebrew"),"iw");
translateLanguages_.insert(QObject::tr("Hebrew"),"iw"); translateLanguages_.insert (QObject::tr ("Hindi"),"hi");
translateLanguages_.insert(QObject::tr("Hindi"),"hi"); translateLanguages_.insert (QObject::tr ("Hungarian"),"hu");
translateLanguages_.insert(QObject::tr("Hungarian"),"hu"); translateLanguages_.insert (QObject::tr ("Icelandic"),"is");
translateLanguages_.insert(QObject::tr("Icelandic"),"is"); translateLanguages_.insert (QObject::tr ("Indonesian"),"id");
translateLanguages_.insert(QObject::tr("Indonesian"),"id"); translateLanguages_.insert (QObject::tr ("Irish"),"ga");
translateLanguages_.insert(QObject::tr("Irish"),"ga"); translateLanguages_.insert (QObject::tr ("Italian"),"it");
translateLanguages_.insert(QObject::tr("Italian"),"it"); translateLanguages_.insert (QObject::tr ("Japanese"),"ja");
translateLanguages_.insert(QObject::tr("Japanese"),"ja"); translateLanguages_.insert (QObject::tr ("Korean"),"ko");
translateLanguages_.insert(QObject::tr("Korean"),"ko"); translateLanguages_.insert (QObject::tr ("Latvian"),"lv");
translateLanguages_.insert(QObject::tr("Latvian"),"lv"); translateLanguages_.insert (QObject::tr ("Lithuanian"),"lt");
translateLanguages_.insert(QObject::tr("Lithuanian"),"lt"); translateLanguages_.insert (QObject::tr ("Macedonian"),"mk");
translateLanguages_.insert(QObject::tr("Macedonian"),"mk"); translateLanguages_.insert (QObject::tr ("Malay"),"ms");
translateLanguages_.insert(QObject::tr("Malay"),"ms"); translateLanguages_.insert (QObject::tr ("Maltese"),"mt");
translateLanguages_.insert(QObject::tr("Maltese"),"mt"); translateLanguages_.insert (QObject::tr ("Norwegian"),"no");
translateLanguages_.insert(QObject::tr("Norwegian"),"no"); translateLanguages_.insert (QObject::tr ("Persian"),"fa");
translateLanguages_.insert(QObject::tr("Persian"),"fa"); translateLanguages_.insert (QObject::tr ("Polish"),"pl");
translateLanguages_.insert(QObject::tr("Polish"),"pl"); translateLanguages_.insert (QObject::tr ("Portuguese"),"pt");
translateLanguages_.insert(QObject::tr("Portuguese"),"pt"); translateLanguages_.insert (QObject::tr ("Romanian"),"ro");
translateLanguages_.insert(QObject::tr("Romanian"),"ro"); translateLanguages_.insert (QObject::tr ("Russian"),"ru");
translateLanguages_.insert(QObject::tr("Russian"),"ru"); translateLanguages_.insert (QObject::tr ("Serbian"),"sr");
translateLanguages_.insert(QObject::tr("Serbian"),"sr"); translateLanguages_.insert (QObject::tr ("Slovak"),"sk");
translateLanguages_.insert(QObject::tr("Slovak"),"sk"); translateLanguages_.insert (QObject::tr ("Slovenian"),"sl");
translateLanguages_.insert(QObject::tr("Slovenian"),"sl"); translateLanguages_.insert (QObject::tr ("Spanish"),"es");
translateLanguages_.insert(QObject::tr("Spanish"),"es"); translateLanguages_.insert (QObject::tr ("Swahili"),"sw");
translateLanguages_.insert(QObject::tr("Swahili"),"sw"); translateLanguages_.insert (QObject::tr ("Swedish"),"sv");
translateLanguages_.insert(QObject::tr("Swedish"),"sv"); translateLanguages_.insert (QObject::tr ("Thai"),"th");
translateLanguages_.insert(QObject::tr("Thai"),"th"); translateLanguages_.insert (QObject::tr ("Turkish"),"tr");
translateLanguages_.insert(QObject::tr("Turkish"),"tr"); translateLanguages_.insert (QObject::tr ("Ukrainian"),"uk");
translateLanguages_.insert(QObject::tr("Ukrainian"),"uk"); translateLanguages_.insert (QObject::tr ("Urdu"),"ur");
translateLanguages_.insert(QObject::tr("Urdu"),"ur"); translateLanguages_.insert (QObject::tr ("Vietnamese"),"vi");
translateLanguages_.insert(QObject::tr("Vietnamese"),"vi"); translateLanguages_.insert (QObject::tr ("Welsh"),"cy");
translateLanguages_.insert(QObject::tr("Welsh"),"cy"); translateLanguages_.insert (QObject::tr ("Yiddish"),"yi");
translateLanguages_.insert(QObject::tr("Yiddish"),"yi");
} }
void LanguageHelper::initOcrLanguages() void LanguageHelper::initOcrLanguages () {
{ ocrLanguages_.insert (QObject::tr ("Ancient Greek"),"grc");
ocrLanguages_.insert(QObject::tr("Ancient Greek"),"grc"); ocrLanguages_.insert (QObject::tr ("Esperanto alternative"),"epo_alt");
ocrLanguages_.insert(QObject::tr("Esperanto alternative"),"epo_alt"); ocrLanguages_.insert (QObject::tr ("English"),"eng");
ocrLanguages_.insert(QObject::tr("English"),"eng"); ocrLanguages_.insert (QObject::tr ("Ukrainian"),"ukr");
ocrLanguages_.insert(QObject::tr("Ukrainian"),"ukr"); ocrLanguages_.insert (QObject::tr ("Turkish"),"tur");
ocrLanguages_.insert(QObject::tr("Turkish"),"tur"); ocrLanguages_.insert (QObject::tr ("Thai"),"tha");
ocrLanguages_.insert(QObject::tr("Thai"),"tha"); ocrLanguages_.insert (QObject::tr ("Tagalog"),"tgl");
ocrLanguages_.insert(QObject::tr("Tagalog"),"tgl"); ocrLanguages_.insert (QObject::tr ("Telugu"),"tel");
ocrLanguages_.insert(QObject::tr("Telugu"),"tel"); ocrLanguages_.insert (QObject::tr ("Tamil"),"tam");
ocrLanguages_.insert(QObject::tr("Tamil"),"tam"); ocrLanguages_.insert (QObject::tr ("Swedish"),"swe");
ocrLanguages_.insert(QObject::tr("Swedish"),"swe"); ocrLanguages_.insert (QObject::tr ("Swahili"),"swa");
ocrLanguages_.insert(QObject::tr("Swahili"),"swa"); ocrLanguages_.insert (QObject::tr ("Serbian"),"srp");
ocrLanguages_.insert(QObject::tr("Serbian"),"srp"); ocrLanguages_.insert (QObject::tr ("Albanian"),"sqi");
ocrLanguages_.insert(QObject::tr("Albanian"),"sqi"); ocrLanguages_.insert (QObject::tr ("Spanish"),"spa");
ocrLanguages_.insert(QObject::tr("Spanish"),"spa"); ocrLanguages_.insert (QObject::tr ("Slovenian"),"slv");
ocrLanguages_.insert(QObject::tr("Slovenian"),"slv"); ocrLanguages_.insert (QObject::tr ("Slovakian"),"slk");
ocrLanguages_.insert(QObject::tr("Slovakian"),"slk"); ocrLanguages_.insert (QObject::tr ("Romanian"),"ron");
ocrLanguages_.insert(QObject::tr("Romanian"),"ron"); ocrLanguages_.insert (QObject::tr ("Portuguese"),"por");
ocrLanguages_.insert(QObject::tr("Portuguese"),"por"); ocrLanguages_.insert (QObject::tr ("Polish"),"pol");
ocrLanguages_.insert(QObject::tr("Polish"),"pol"); ocrLanguages_.insert (QObject::tr ("Norwegian"),"nor");
ocrLanguages_.insert(QObject::tr("Norwegian"),"nor"); ocrLanguages_.insert (QObject::tr ("Dutch"),"nld");
ocrLanguages_.insert(QObject::tr("Dutch"),"nld"); ocrLanguages_.insert (QObject::tr ("Malay"),"msa");
ocrLanguages_.insert(QObject::tr("Malay"),"msa"); ocrLanguages_.insert (QObject::tr ("Maltese"),"mlt");
ocrLanguages_.insert(QObject::tr("Maltese"),"mlt"); ocrLanguages_.insert (QObject::tr ("Macedonian"),"mkd");
ocrLanguages_.insert(QObject::tr("Macedonian"),"mkd"); ocrLanguages_.insert (QObject::tr ("Malayalam"),"mal");
ocrLanguages_.insert(QObject::tr("Malayalam"),"mal"); ocrLanguages_.insert (QObject::tr ("Lithuanian"),"lit");
ocrLanguages_.insert(QObject::tr("Lithuanian"),"lit"); ocrLanguages_.insert (QObject::tr ("Latvian"),"lav");
ocrLanguages_.insert(QObject::tr("Latvian"),"lav"); ocrLanguages_.insert (QObject::tr ("Korean"),"kor");
ocrLanguages_.insert(QObject::tr("Korean"),"kor"); ocrLanguages_.insert (QObject::tr ("Kannada"),"kan");
ocrLanguages_.insert(QObject::tr("Kannada"),"kan"); ocrLanguages_.insert (QObject::tr ("Italian"),"ita");
ocrLanguages_.insert(QObject::tr("Italian"),"ita"); ocrLanguages_.insert (QObject::tr ("Icelandic"),"isl");
ocrLanguages_.insert(QObject::tr("Icelandic"),"isl"); ocrLanguages_.insert (QObject::tr ("Indonesian"),"ind");
ocrLanguages_.insert(QObject::tr("Indonesian"),"ind"); ocrLanguages_.insert (QObject::tr ("Cherokee"),"chr");
ocrLanguages_.insert(QObject::tr("Cherokee"),"chr"); ocrLanguages_.insert (QObject::tr ("Hungarian"),"hun");
ocrLanguages_.insert(QObject::tr("Hungarian"),"hun"); ocrLanguages_.insert (QObject::tr ("Croatian"),"hrv");
ocrLanguages_.insert(QObject::tr("Croatian"),"hrv"); ocrLanguages_.insert (QObject::tr ("Hindi"),"hin");
ocrLanguages_.insert(QObject::tr("Hindi"),"hin"); ocrLanguages_.insert (QObject::tr ("Hebrew"),"heb");
ocrLanguages_.insert(QObject::tr("Hebrew"),"heb"); ocrLanguages_.insert (QObject::tr ("Galician"),"glg");
ocrLanguages_.insert(QObject::tr("Galician"),"glg"); ocrLanguages_.insert (QObject::tr ("Middle French (ca. 1400-1600)"),"frm");
ocrLanguages_.insert(QObject::tr("Middle French (ca. 1400-1600)"),"frm"); ocrLanguages_.insert (QObject::tr ("Frankish"),"frk");
ocrLanguages_.insert(QObject::tr("Frankish"),"frk"); ocrLanguages_.insert (QObject::tr ("French"),"fra");
ocrLanguages_.insert(QObject::tr("French"),"fra"); ocrLanguages_.insert (QObject::tr ("Finnish"),"fin");
ocrLanguages_.insert(QObject::tr("Finnish"),"fin"); ocrLanguages_.insert (QObject::tr ("Basque"),"eus");
ocrLanguages_.insert(QObject::tr("Basque"),"eus"); ocrLanguages_.insert (QObject::tr ("Estonian"),"est");
ocrLanguages_.insert(QObject::tr("Estonian"),"est"); ocrLanguages_.insert (QObject::tr ("Math / equation"),"equ");
ocrLanguages_.insert(QObject::tr("Math / equation"),"equ"); ocrLanguages_.insert (QObject::tr ("Esperanto"),"epo");
ocrLanguages_.insert(QObject::tr("Esperanto"),"epo"); ocrLanguages_.insert (QObject::tr ("Middle English (1100-1500)"),"enm");
ocrLanguages_.insert(QObject::tr("Middle English (1100-1500)"),"enm"); ocrLanguages_.insert (QObject::tr ("Greek"),"ell");
ocrLanguages_.insert(QObject::tr("Greek"),"ell"); ocrLanguages_.insert (QObject::tr ("German"),"deu");
ocrLanguages_.insert(QObject::tr("German"),"deu"); ocrLanguages_.insert (QObject::tr ("Danish"),"dan");
ocrLanguages_.insert(QObject::tr("Danish"),"dan"); ocrLanguages_.insert (QObject::tr ("Czech"),"ces");
ocrLanguages_.insert(QObject::tr("Czech"),"ces"); ocrLanguages_.insert (QObject::tr ("Catalan"),"cat");
ocrLanguages_.insert(QObject::tr("Catalan"),"cat"); ocrLanguages_.insert (QObject::tr ("Bulgarian"),"bul");
ocrLanguages_.insert(QObject::tr("Bulgarian"),"bul"); ocrLanguages_.insert (QObject::tr ("Bengali"),"ben");
ocrLanguages_.insert(QObject::tr("Bengali"),"ben"); ocrLanguages_.insert (QObject::tr ("Belarusian"),"bel");
ocrLanguages_.insert(QObject::tr("Belarusian"),"bel"); ocrLanguages_.insert (QObject::tr ("Azerbaijani"),"aze");
ocrLanguages_.insert(QObject::tr("Azerbaijani"),"aze"); ocrLanguages_.insert (QObject::tr ("Arabic"),"ara");
ocrLanguages_.insert(QObject::tr("Arabic"),"ara"); ocrLanguages_.insert (QObject::tr ("Afrikaans"),"afr");
ocrLanguages_.insert(QObject::tr("Afrikaans"),"afr"); ocrLanguages_.insert (QObject::tr ("Japanese"),"jpn");
ocrLanguages_.insert(QObject::tr("Japanese"),"jpn"); ocrLanguages_.insert (QObject::tr ("Chinese (Simplified)"),"chi_sim");
ocrLanguages_.insert(QObject::tr("Chinese (Simplified)"),"chi_sim"); ocrLanguages_.insert (QObject::tr ("Chinese (Traditional)"),"chi_tra");
ocrLanguages_.insert(QObject::tr("Chinese (Traditional)"),"chi_tra"); ocrLanguages_.insert (QObject::tr ("Russian"),"rus");
ocrLanguages_.insert(QObject::tr("Russian"),"rus"); ocrLanguages_.insert (QObject::tr ("Vietnamese"),"vie");
ocrLanguages_.insert(QObject::tr("Vietnamese"),"vie");
} }

19
LanguageHelper.h
View File

@ -4,27 +4,26 @@
#include <QMap> #include <QMap>
#include <QStringList> #include <QStringList>
class LanguageHelper class LanguageHelper {
{
public: public:
LanguageHelper (); LanguageHelper ();
QStringList availableOcrLanguagesUi () const; QStringList availableOcrLanguagesUi () const;
const QStringList& availableOcrLanguages () const; const QStringList &availableOcrLanguages () const;
QStringList availableOcrLanguagesUi (const QString& path) const; QStringList availableOcrLanguagesUi (const QString &path) const;
QStringList translateLanguagesUi () const; QStringList translateLanguagesUi () const;
QStringList translateLanguages () const; QStringList translateLanguages () const;
QString translateCodeToUi (const QString& text) const; QString translateCodeToUi (const QString &text) const;
QString translateUiToCode (const QString& text) const; QString translateUiToCode (const QString &text) const;
QString ocrCodeToUi (const QString& text) const; QString ocrCodeToUi (const QString &text) const;
QString ocrUiToCode (const QString& text) const; QString ocrUiToCode (const QString &text) const;
QString translateForOcrCode (const QString& text) const; QString translateForOcrCode (const QString &text) const;
void updateAvailableOcrLanguages (); void updateAvailableOcrLanguages ();
private: private:
QStringList availableOcrLanguages (const QString& path) const; QStringList availableOcrLanguages (const QString &path) const;
void init (); void init ();
void initTranslateLanguages (); void initTranslateLanguages ();
void initOcrLanguages (); void initOcrLanguages ();

81
Manager.cpp
View File

@ -20,41 +20,40 @@
#include "LanguageHelper.h" #include "LanguageHelper.h"
#include "StAssert.h" #include "StAssert.h"
Manager::Manager(QObject *parent) : Manager::Manager (QObject *parent) :
QObject(parent), QObject (parent),
trayIcon_ (new QSystemTrayIcon (QIcon (":/images/icon.png"), this)), trayIcon_ (new QSystemTrayIcon (QIcon (":/images/icon.png"), this)),
dictionary_ (new LanguageHelper), dictionary_ (new LanguageHelper),
selection_ (new SelectionDialog (*dictionary_)), selection_ (new SelectionDialog (*dictionary_)),
resultDialog_ (new ResultDialog), resultDialog_ (new ResultDialog),
captureAction_ (NULL), repeatAction_ (NULL), clipboardAction_ (NULL), captureAction_ (NULL), repeatAction_ (NULL), clipboardAction_ (NULL),
useResultDialog_ (true) useResultDialog_ (true) {
{
GlobalActionHelper::init (); GlobalActionHelper::init ();
qRegisterMetaType<ProcessingItem>(); qRegisterMetaType<ProcessingItem>();
// Recognizer // Recognizer
Recognizer* recognizer = new Recognizer; Recognizer *recognizer = new Recognizer;
connect (selection_, SIGNAL (selected (ProcessingItem)), connect (selection_, SIGNAL (selected (ProcessingItem)),
recognizer, SLOT (recognize (ProcessingItem))); recognizer, SLOT (recognize (ProcessingItem)));
connect (recognizer, SIGNAL (error (QString)), connect (recognizer, SIGNAL (error (QString)),
SLOT (showError (QString))); SLOT (showError (QString)));
connect (this, SIGNAL (settingsEdited ()), connect (this, SIGNAL (settingsEdited ()),
recognizer, SLOT (applySettings ())); recognizer, SLOT (applySettings ()));
QThread* recognizerThread = new QThread (this); QThread *recognizerThread = new QThread (this);
recognizer->moveToThread (recognizerThread); recognizer->moveToThread (recognizerThread);
recognizerThread->start (); recognizerThread->start ();
connect (qApp, SIGNAL (aboutToQuit ()), recognizerThread, SLOT (quit ())); connect (qApp, SIGNAL (aboutToQuit ()), recognizerThread, SLOT (quit ()));
// Translator // Translator
Translator* translator = new Translator; Translator *translator = new Translator;
connect (recognizer, SIGNAL (recognized (ProcessingItem)), connect (recognizer, SIGNAL (recognized (ProcessingItem)),
translator, SLOT (translate (ProcessingItem))); translator, SLOT (translate (ProcessingItem)));
connect (translator, SIGNAL (error (QString)), connect (translator, SIGNAL (error (QString)),
SLOT (showError (QString))); SLOT (showError (QString)));
connect (this, SIGNAL (settingsEdited ()), connect (this, SIGNAL (settingsEdited ()),
translator, SLOT (applySettings ())); translator, SLOT (applySettings ()));
QThread* translatorThread = new QThread (this); QThread *translatorThread = new QThread (this);
translator->moveToThread (translatorThread); translator->moveToThread (translatorThread);
translatorThread->start (); translatorThread->start ();
connect (qApp, SIGNAL (aboutToQuit ()), translatorThread, SLOT (quit ())); connect (qApp, SIGNAL (aboutToQuit ()), translatorThread, SLOT (quit ()));
@ -80,11 +79,10 @@ Manager::Manager(QObject *parent) :
applySettings (); applySettings ();
} }
QMenu*Manager::trayContextMenu() QMenu * Manager::trayContextMenu () {
{ QMenu *menu = new QMenu ();
QMenu* menu = new QMenu ();
captureAction_ = menu->addAction (tr ("Захват"), this, SLOT (capture ())); captureAction_ = menu->addAction (tr ("Захват"), this, SLOT (capture ()));
QMenu* translateMenu = menu->addMenu (tr ("Перевод")); QMenu *translateMenu = menu->addMenu (tr ("Перевод"));
repeatAction_ = translateMenu->addAction (tr ("Повторить"), this, repeatAction_ = translateMenu->addAction (tr ("Повторить"), this,
SLOT (showLast ())); SLOT (showLast ()));
clipboardAction_ = translateMenu->addAction (tr ("Скопировать"), this, clipboardAction_ = translateMenu->addAction (tr ("Скопировать"), this,
@ -95,8 +93,7 @@ QMenu*Manager::trayContextMenu()
return menu; return menu;
} }
void Manager::applySettings() void Manager::applySettings () {
{
QSettings settings; QSettings settings;
settings.beginGroup (settings_names::guiGroup); settings.beginGroup (settings_names::guiGroup);
QString captureHotkey = settings.value (settings_names::captureHotkey, QString captureHotkey = settings.value (settings_names::captureHotkey,
@ -128,15 +125,13 @@ void Manager::applySettings()
dictionary_->updateAvailableOcrLanguages (); dictionary_->updateAvailableOcrLanguages ();
} }
Manager::~Manager() Manager::~Manager () {
{
} }
void Manager::capture() void Manager::capture () {
{ QList<QScreen *> screens = QApplication::screens ();
QList<QScreen*> screens = QApplication::screens ();
ST_ASSERT (!screens.isEmpty ()); ST_ASSERT (!screens.isEmpty ());
QScreen* screen = screens.first (); QScreen *screen = screens.first ();
Q_CHECK_PTR (screen); Q_CHECK_PTR (screen);
WId desktopId = QApplication::desktop ()->winId (); WId desktopId = QApplication::desktop ()->winId ();
QPixmap pixmap = screen->grabWindow (desktopId); QPixmap pixmap = screen->grabWindow (desktopId);
@ -144,23 +139,20 @@ void Manager::capture()
emit showPixmap (pixmap); emit showPixmap (pixmap);
} }
void Manager::settings() void Manager::settings () {
{
SettingsEditor editor (*dictionary_); SettingsEditor editor (*dictionary_);
editor.setWindowIcon (trayIcon_->icon ()); editor.setWindowIcon (trayIcon_->icon ());
connect (&editor, SIGNAL (settingsEdited ()), SIGNAL (settingsEdited ())); connect (&editor, SIGNAL (settingsEdited ()), SIGNAL (settingsEdited ()));
editor.exec (); editor.exec ();
} }
void Manager::close() void Manager::close () {
{
QApplication::quit (); QApplication::quit ();
} }
void Manager::about() void Manager::about () {
{
QString version = "1.2.3"; QString version = "1.2.3";
QString text = tr ("Программа для распознавания текста на экране.\n"\ QString text = tr ("Программа для распознавания текста на экране.\n" \
"Создана с использованием Qt, tesseract-ocr, Google Translate.\n" "Создана с использованием Qt, tesseract-ocr, Google Translate.\n"
"Автор: Gres (translator@gres.biz)\n" "Автор: Gres (translator@gres.biz)\n"
"Версия: %1 от %2 %3").arg (version) "Версия: %1 от %2 %3").arg (version)
@ -172,31 +164,24 @@ void Manager::about()
message.exec (); message.exec ();
} }
void Manager::processTrayAction(QSystemTrayIcon::ActivationReason reason) void Manager::processTrayAction (QSystemTrayIcon::ActivationReason reason) {
{ if (reason == QSystemTrayIcon::Trigger) {
if (reason == QSystemTrayIcon::Trigger)
{
showLast (); showLast ();
} }
else if (reason == QSystemTrayIcon::MiddleClick) else if (reason == QSystemTrayIcon::MiddleClick) {
{
copyLastToClipboard (); copyLastToClipboard ();
} }
} }
void Manager::showLast() void Manager::showLast () {
{ if (lastItem_.isValid ()) {
if (lastItem_.isValid ())
{
showResult (lastItem_); showResult (lastItem_);
} }
} }
void Manager::copyLastToClipboard() void Manager::copyLastToClipboard () {
{ if (lastItem_.isValid ()) {
if (lastItem_.isValid ()) QClipboard *clipboard = QApplication::clipboard ();
{
QClipboard* clipboard = QApplication::clipboard ();
QString message = lastItem_.recognized + " - " + lastItem_.translated; QString message = lastItem_.recognized + " - " + lastItem_.translated;
clipboard->setText (message); clipboard->setText (message);
trayIcon_->showMessage (tr ("Перевод"), trayIcon_->showMessage (tr ("Перевод"),
@ -205,23 +190,19 @@ void Manager::copyLastToClipboard()
} }
} }
void Manager::showResult(ProcessingItem item) void Manager::showResult (ProcessingItem item) {
{
ST_ASSERT (item.isValid ()); ST_ASSERT (item.isValid ());
lastItem_ = item; lastItem_ = item;
if (useResultDialog_) if (useResultDialog_) {
{
resultDialog_->showResult (item); resultDialog_->showResult (item);
} }
else else {
{
QString message = item.recognized + " - " + item.translated; QString message = item.recognized + " - " + item.translated;
trayIcon_->showMessage (tr ("Перевод"), message, QSystemTrayIcon::Information); trayIcon_->showMessage (tr ("Перевод"), message, QSystemTrayIcon::Information);
} }
} }
void Manager::showError(QString text) void Manager::showError (QString text) {
{
qCritical () << text; qCritical () << text;
trayIcon_->showMessage (tr ("Ошибка"), text, QSystemTrayIcon::Critical); trayIcon_->showMessage (tr ("Ошибка"), text, QSystemTrayIcon::Critical);
} }

22
Manager.h
View File

@ -13,11 +13,11 @@ class SelectionDialog;
class ResultDialog; class ResultDialog;
class LanguageHelper; class LanguageHelper;
class Manager : public QObject class Manager : public QObject {
{
Q_OBJECT Q_OBJECT
public: public:
explicit Manager(QObject *parent = 0); explicit Manager (QObject *parent = 0);
~Manager (); ~Manager ();
signals: signals:
@ -40,16 +40,16 @@ class Manager : public QObject
void showError (QString text); void showError (QString text);
private: private:
QMenu* trayContextMenu (); QMenu * trayContextMenu ();
private: private:
QSystemTrayIcon* trayIcon_; QSystemTrayIcon *trayIcon_;
LanguageHelper* dictionary_; LanguageHelper *dictionary_;
SelectionDialog* selection_; SelectionDialog *selection_;
ResultDialog* resultDialog_; ResultDialog *resultDialog_;
QAction* captureAction_; QAction *captureAction_;
QAction* repeatAction_; QAction *repeatAction_;
QAction* clipboardAction_; QAction *clipboardAction_;
ProcessingItem lastItem_; ProcessingItem lastItem_;
bool useResultDialog_; bool useResultDialog_;
}; };

3
ProcessingItem.cpp
View File

@ -1,7 +1,6 @@
#include "ProcessingItem.h" #include "ProcessingItem.h"
bool ProcessingItem::isValid() const bool ProcessingItem::isValid () const {
{
bool valid = true; bool valid = true;
valid &= (!screenPos.isNull ()); valid &= (!screenPos.isNull ());
valid &= (!source.isNull ()); valid &= (!source.isNull ());

5
ProcessingItem.h
View File

@ -3,8 +3,7 @@
#include <QPixmap> #include <QPixmap>
struct ProcessingItem struct ProcessingItem {
{
QPoint screenPos; QPoint screenPos;
QPixmap source; QPixmap source;
QString recognized; QString recognized;
@ -15,6 +14,6 @@ struct ProcessingItem
bool isValid () const; bool isValid () const;
}; };
Q_DECLARE_METATYPE(ProcessingItem) Q_DECLARE_METATYPE (ProcessingItem)
#endif // PROCESSINGITEM_H #endif // PROCESSINGITEM_H

55
Recognizer.cpp
View File

@ -9,22 +9,19 @@
#include "ImageProcessing.h" #include "ImageProcessing.h"
#include "StAssert.h" #include "StAssert.h"
Recognizer::Recognizer(QObject *parent) : Recognizer::Recognizer (QObject *parent) :
QObject(parent), QObject (parent),
engine_ (NULL), imageScale_ (0) engine_ (NULL), imageScale_ (0) {
{
applySettings (); applySettings ();
} }
void Recognizer::applySettings() void Recognizer::applySettings () {
{
QSettings settings; QSettings settings;
settings.beginGroup (settings_names::recogntionGroup); settings.beginGroup (settings_names::recogntionGroup);
tessDataDir_ = settings.value (settings_names::tessDataPlace, tessDataDir_ = settings.value (settings_names::tessDataPlace,
settings_values::tessDataPlace).toString (); settings_values::tessDataPlace).toString ();
if (tessDataDir_.right (1) != "/") if (tessDataDir_.right (1) != "/") {
{
tessDataDir_ += "/"; tessDataDir_ += "/";
} }
ocrLanguage_ = settings.value (settings_names::ocrLanguage, ocrLanguage_ = settings.value (settings_names::ocrLanguage,
@ -35,22 +32,18 @@ void Recognizer::applySettings()
initEngine (engine_, ocrLanguage_); initEngine (engine_, ocrLanguage_);
} }
bool Recognizer::initEngine(tesseract::TessBaseAPI *&engine, const QString& language) bool Recognizer::initEngine (tesseract::TessBaseAPI * &engine, const QString &language) {
{ if (tessDataDir_.isEmpty () || language.isEmpty ()) {
if (tessDataDir_.isEmpty () || language.isEmpty ())
{
emit error (tr ("Неверные параметры для OCR")); emit error (tr ("Неверные параметры для OCR"));
return false; return false;
} }
if (engine != NULL) if (engine != NULL) {
{
delete engine; delete engine;
} }
engine = new tesseract::TessBaseAPI(); engine = new tesseract::TessBaseAPI ();
int result = engine->Init(qPrintable (tessDataDir_), qPrintable (language), int result = engine->Init (qPrintable (tessDataDir_), qPrintable (language),
tesseract::OEM_DEFAULT); tesseract::OEM_DEFAULT);
if (result != 0) if (result != 0) {
{
emit error (tr ("Ошибка инициализации OCR: %1").arg (result)); emit error (tr ("Ошибка инициализации OCR: %1").arg (result));
delete engine; delete engine;
engine = NULL; engine = NULL;
@ -59,42 +52,36 @@ bool Recognizer::initEngine(tesseract::TessBaseAPI *&engine, const QString& lang
return true; return true;
} }
void Recognizer::recognize(ProcessingItem item) void Recognizer::recognize (ProcessingItem item) {
{
ST_ASSERT (!item.source.isNull ()); ST_ASSERT (!item.source.isNull ());
bool isCustomLanguage = (!item.ocrLanguage.isEmpty () && bool isCustomLanguage = (!item.ocrLanguage.isEmpty () &&
item.ocrLanguage != ocrLanguage_); item.ocrLanguage != ocrLanguage_);
tesseract::TessBaseAPI* engine = (isCustomLanguage) ? NULL : engine_; tesseract::TessBaseAPI *engine = (isCustomLanguage) ? NULL : engine_;
if (engine == NULL) if (engine == NULL) {
{
QString language = (isCustomLanguage) ? item.ocrLanguage : ocrLanguage_; QString language = (isCustomLanguage) ? item.ocrLanguage : ocrLanguage_;
if (!initEngine (engine, language)) if (!initEngine (engine, language)) {
{
return; return;
} }
} }
Pix* image = prepareImage (item.source.toImage (), imageScale_); Pix *image = prepareImage (item.source.toImage (), imageScale_);
ST_ASSERT (image != NULL); ST_ASSERT (image != NULL);
engine->SetImage (image); engine->SetImage (image);
char* outText = engine->GetUTF8Text(); char *outText = engine->GetUTF8Text ();
engine->Clear(); engine->Clear ();
cleanupImage (&image); cleanupImage (&image);
QString result = QString (outText).trimmed (); QString result = QString (outText).trimmed ();
delete [] outText; delete [] outText;
if (isCustomLanguage) if (isCustomLanguage) {
{
delete engine; delete engine;
} }
if (!result.isEmpty ()) if (!result.isEmpty ()) {
{
item.recognized = result; item.recognized = result;
emit recognized (item); emit recognized (item);
} }
else else {
{
emit error (tr ("Текст не распознан.")); emit error (tr ("Текст не распознан."));
} }
} }

13
Recognizer.h
View File

@ -6,16 +6,15 @@
#include "ProcessingItem.h" #include "ProcessingItem.h"
namespace tesseract namespace tesseract {
{
class TessBaseAPI; class TessBaseAPI;
} }
class Recognizer : public QObject class Recognizer : public QObject {
{
Q_OBJECT Q_OBJECT
public: public:
explicit Recognizer(QObject *parent = 0); explicit Recognizer (QObject *parent = 0);
signals: signals:
void recognized (ProcessingItem item); void recognized (ProcessingItem item);
@ -26,10 +25,10 @@ class Recognizer : public QObject
void applySettings (); void applySettings ();
private: private:
bool initEngine (tesseract::TessBaseAPI*&engine, const QString &language); bool initEngine (tesseract::TessBaseAPI * &engine, const QString &language);
private: private:
tesseract::TessBaseAPI* engine_; tesseract::TessBaseAPI *engine_;
QString tessDataDir_; QString tessDataDir_;
QString ocrLanguage_; QString ocrLanguage_;

34
ResultDialog.cpp
View File

@ -4,35 +4,30 @@
#include <QDesktopWidget> #include <QDesktopWidget>
ResultDialog::ResultDialog(QWidget *parent) : ResultDialog::ResultDialog (QWidget *parent) :
QDialog(parent), QDialog (parent),
ui(new Ui::ResultDialog), ui (new Ui::ResultDialog),
isShowAtCapturePos_ (true) isShowAtCapturePos_ (true) {
{ ui->setupUi (this);
ui->setupUi(this);
setWindowFlags (Qt::FramelessWindowHint | Qt::NoDropShadowWindowHint | setWindowFlags (Qt::FramelessWindowHint | Qt::NoDropShadowWindowHint |
Qt::WindowStaysOnTopHint); Qt::WindowStaysOnTopHint);
installEventFilter (this); installEventFilter (this);
} }
ResultDialog::~ResultDialog() ResultDialog::~ResultDialog () {
{
delete ui; delete ui;
} }
bool ResultDialog::eventFilter(QObject* object, QEvent* event) bool ResultDialog::eventFilter (QObject *object, QEvent *event) {
{
Q_UNUSED (object); Q_UNUSED (object);
if (event->type () == QEvent::MouseButtonRelease) if (event->type () == QEvent::MouseButtonRelease) {
{
hide (); hide ();
} }
return QDialog::eventFilter (object, event); return QDialog::eventFilter (object, event);
} }
void ResultDialog::showResult(ProcessingItem item) void ResultDialog::showResult (ProcessingItem item) {
{
ST_ASSERT (!item.source.isNull ()); ST_ASSERT (!item.source.isNull ());
ST_ASSERT (!item.recognized.isEmpty ()); ST_ASSERT (!item.recognized.isEmpty ());
ST_ASSERT (!item.translated.isEmpty ()); ST_ASSERT (!item.translated.isEmpty ());
@ -45,21 +40,18 @@ void ResultDialog::showResult(ProcessingItem item)
show (); show ();
adjustSize (); adjustSize ();
QDesktopWidget* desktop = QApplication::desktop (); QDesktopWidget *desktop = QApplication::desktop ();
Q_CHECK_PTR (desktop); Q_CHECK_PTR (desktop);
if (isShowAtCapturePos_) if (isShowAtCapturePos_) {
{
QPoint correction = QPoint (ui->frame->lineWidth (), ui->frame->lineWidth ()); QPoint correction = QPoint (ui->frame->lineWidth (), ui->frame->lineWidth ());
move (item.screenPos - correction); move (item.screenPos - correction);
QRect screenRect = desktop->screenGeometry (this); QRect screenRect = desktop->screenGeometry (this);
int minY = screenRect.bottom () - height (); int minY = screenRect.bottom () - height ();
if (y () > minY) if (y () > minY) {
{
move (x (), minY); move (x (), minY);
} }
} }
else else {
{
QRect screenRect = desktop->availableGeometry (this); QRect screenRect = desktop->availableGeometry (this);
ST_ASSERT (screenRect.isValid ()); ST_ASSERT (screenRect.isValid ());

7
ResultDialog.h
View File

@ -9,13 +9,12 @@ namespace Ui {
class ResultDialog; class ResultDialog;
} }
class ResultDialog : public QDialog class ResultDialog : public QDialog {
{
Q_OBJECT Q_OBJECT
public: public:
explicit ResultDialog(QWidget *parent = 0); explicit ResultDialog (QWidget *parent = 0);
~ResultDialog(); ~ResultDialog ();
public: public:
bool eventFilter (QObject *object, QEvent *event); bool eventFilter (QObject *object, QEvent *event);

3
ScreenTranslator.pro
View File

@ -63,4 +63,5 @@ RC_FILE = app.rc
OTHER_FILES += \ OTHER_FILES += \
app.rc \ app.rc \
images/icon.ico \ images/icon.ico \
README.md README.md \
uncrustify.cfg

98
SelectionDialog.cpp
View File

@ -8,57 +8,47 @@
#include <QDebug> #include <QDebug>
#include <QMenu> #include <QMenu>
SelectionDialog::SelectionDialog(const LanguageHelper &dictionary, QWidget *parent) : SelectionDialog::SelectionDialog (const LanguageHelper &dictionary, QWidget *parent) :
QDialog(parent), QDialog (parent),
ui(new Ui::SelectionDialog), dictionary_ (dictionary), ui (new Ui::SelectionDialog), dictionary_ (dictionary),
languageMenu_ (new QMenu) languageMenu_ (new QMenu) {
{ ui->setupUi (this);
ui->setupUi(this);
setWindowFlags (Qt::FramelessWindowHint | Qt::NoDropShadowWindowHint | setWindowFlags (Qt::FramelessWindowHint | Qt::NoDropShadowWindowHint |
Qt::WindowStaysOnTopHint); Qt::WindowStaysOnTopHint);
ui->label->setAutoFillBackground(false); ui->label->setAutoFillBackground (false);
ui->label->installEventFilter (this); ui->label->installEventFilter (this);
updateMenu (); updateMenu ();
} }
SelectionDialog::~SelectionDialog() SelectionDialog::~SelectionDialog () {
{
delete ui; delete ui;
} }
void SelectionDialog::updateMenu() void SelectionDialog::updateMenu () {
{
Q_CHECK_PTR (languageMenu_); Q_CHECK_PTR (languageMenu_);
languageMenu_->clear (); languageMenu_->clear ();
QStringList languages = dictionary_.availableOcrLanguagesUi (); QStringList languages = dictionary_.availableOcrLanguagesUi ();
if (languages.isEmpty ()) if (languages.isEmpty ()) {
{
return; return;
} }
const int max = 10; const int max = 10;
if (languages.size () <= max) if (languages.size () <= max) {
{ foreach (const QString &language, languages) {
foreach (const QString& language, languages)
{
languageMenu_->addAction (language); languageMenu_->addAction (language);
} }
} }
else else {
{
int subIndex = max; int subIndex = max;
QMenu* subMenu = NULL; QMenu *subMenu = NULL;
QString prevLetter; QString prevLetter;
foreach (const QString& language, languages) foreach (const QString &language, languages) {
{
QString curLetter = language.left (1); QString curLetter = language.left (1);
if (++subIndex >= max && prevLetter != curLetter) if (++subIndex >= max && prevLetter != curLetter) {
{ if (subMenu != NULL) {
if (subMenu != NULL)
{
subMenu->setTitle (subMenu->title () + " - " + prevLetter); subMenu->setTitle (subMenu->title () + " - " + prevLetter);
} }
subMenu = languageMenu_->addMenu (curLetter); subMenu = languageMenu_->addMenu (curLetter);
@ -71,71 +61,56 @@ void SelectionDialog::updateMenu()
} }
} }
bool SelectionDialog::eventFilter(QObject* object, QEvent* event) bool SelectionDialog::eventFilter (QObject *object, QEvent *event) {
{ if (object != ui->label) {
if (object != ui->label)
{
return QDialog::eventFilter (object, event); return QDialog::eventFilter (object, event);
} }
if (event->type () == QEvent::Show) if (event->type () == QEvent::Show) {
{
startSelectPos_ = currentSelectPos_ = QPoint (); startSelectPos_ = currentSelectPos_ = QPoint ();
} }
else if (event->type () == QEvent::MouseButtonPress) else if (event->type () == QEvent::MouseButtonPress) {
{ QMouseEvent *mouseEvent = static_cast <QMouseEvent *> (event);
QMouseEvent* mouseEvent = static_cast <QMouseEvent*> (event);
if ((mouseEvent->button () == Qt::LeftButton || if ((mouseEvent->button () == Qt::LeftButton ||
mouseEvent->button () == Qt::RightButton) && startSelectPos_.isNull ()) mouseEvent->button () == Qt::RightButton) && startSelectPos_.isNull ()) {
{
startSelectPos_ = mouseEvent->pos (); startSelectPos_ = mouseEvent->pos ();
} }
} }
else if (event->type () == QEvent::MouseMove) else if (event->type () == QEvent::MouseMove) {
{ QMouseEvent *mouseEvent = static_cast <QMouseEvent *> (event);
QMouseEvent* mouseEvent = static_cast <QMouseEvent*> (event);
if ((mouseEvent->buttons () & Qt::LeftButton || if ((mouseEvent->buttons () & Qt::LeftButton ||
mouseEvent->buttons () & Qt::RightButton) && !startSelectPos_.isNull ()) mouseEvent->buttons () & Qt::RightButton) && !startSelectPos_.isNull ()) {
{
currentSelectPos_ = mouseEvent->pos (); currentSelectPos_ = mouseEvent->pos ();
ui->label->repaint (); ui->label->repaint ();
} }
} }
else if (event->type () == QEvent::Paint) else if (event->type () == QEvent::Paint) {
{
QRect selection = QRect (startSelectPos_, currentSelectPos_).normalized (); QRect selection = QRect (startSelectPos_, currentSelectPos_).normalized ();
if (selection.isValid ()) if (selection.isValid ()) {
{
QPainter painter (ui->label); QPainter painter (ui->label);
painter.setPen (Qt::red); painter.setPen (Qt::red);
painter.drawRect (selection); painter.drawRect (selection);
} }
} }
else if (event->type () == QEvent::MouseButtonRelease) else if (event->type () == QEvent::MouseButtonRelease) {
{ QMouseEvent *mouseEvent = static_cast <QMouseEvent *> (event);
QMouseEvent* mouseEvent = static_cast <QMouseEvent*> (event);
if (mouseEvent->button () == Qt::LeftButton || if (mouseEvent->button () == Qt::LeftButton ||
mouseEvent->button () == Qt::RightButton) mouseEvent->button () == Qt::RightButton) {
{ if (startSelectPos_.isNull () || currentPixmap_.isNull ()) {
if (startSelectPos_.isNull () || currentPixmap_.isNull ())
{
return QDialog::eventFilter (object, event); return QDialog::eventFilter (object, event);
} }
QPoint endPos = mouseEvent->pos (); QPoint endPos = mouseEvent->pos ();
QRect selection = QRect (startSelectPos_, endPos).normalized (); QRect selection = QRect (startSelectPos_, endPos).normalized ();
QPixmap selectedPixmap = currentPixmap_.copy (selection); QPixmap selectedPixmap = currentPixmap_.copy (selection);
if (!selectedPixmap.isNull ()) if (!selectedPixmap.isNull ()) {
{
ProcessingItem item; ProcessingItem item;
item.source = selectedPixmap; item.source = selectedPixmap;
item.screenPos = selection.topLeft (); item.screenPos = selection.topLeft ();
if (mouseEvent->button () == Qt::RightButton && if (mouseEvent->button () == Qt::RightButton &&
!languageMenu_->children ().isEmpty ()) !languageMenu_->children ().isEmpty ()) {
{ QAction *action = languageMenu_->exec (QCursor::pos ());
QAction* action = languageMenu_->exec (QCursor::pos ()); if (action == NULL) {
if (action == NULL)
{
reject (); reject ();
return QDialog::eventFilter (object, event); return QDialog::eventFilter (object, event);
} }
@ -152,8 +127,7 @@ bool SelectionDialog::eventFilter(QObject* object, QEvent* event)
return QDialog::eventFilter (object, event); return QDialog::eventFilter (object, event);
} }
void SelectionDialog::setPixmap(QPixmap pixmap) void SelectionDialog::setPixmap (QPixmap pixmap) {
{
ST_ASSERT (!pixmap.isNull ()); ST_ASSERT (!pixmap.isNull ());
currentPixmap_ = pixmap; currentPixmap_ = pixmap;
QPalette palette = this->palette (); QPalette palette = this->palette ();

11
SelectionDialog.h
View File

@ -12,13 +12,12 @@ namespace Ui {
} }
class LanguageHelper; class LanguageHelper;
class SelectionDialog : public QDialog class SelectionDialog : public QDialog {
{
Q_OBJECT Q_OBJECT
public: public:
explicit SelectionDialog(const LanguageHelper& dictionary, QWidget *parent = 0); explicit SelectionDialog (const LanguageHelper &dictionary, QWidget *parent = 0);
~SelectionDialog(); ~SelectionDialog ();
bool eventFilter (QObject *object, QEvent *event); bool eventFilter (QObject *object, QEvent *event);
@ -31,11 +30,11 @@ class SelectionDialog : public QDialog
private: private:
Ui::SelectionDialog *ui; Ui::SelectionDialog *ui;
const LanguageHelper& dictionary_; const LanguageHelper &dictionary_;
QPoint startSelectPos_; QPoint startSelectPos_;
QPoint currentSelectPos_; QPoint currentSelectPos_;
QPixmap currentPixmap_; QPixmap currentPixmap_;
QMenu* languageMenu_; QMenu *languageMenu_;
}; };
#endif // SELECTIONDIALOG_H #endif // SELECTIONDIALOG_H

6
Settings.h
View File

@ -3,8 +3,7 @@
#include <QString> #include <QString>
namespace settings_names namespace settings_names {
{
//! UI //! UI
const QString guiGroup = "GUI"; const QString guiGroup = "GUI";
const QString geometry = "geometry"; const QString geometry = "geometry";
@ -26,8 +25,7 @@ namespace settings_names
} }
namespace settings_values namespace settings_values {
{
const QString appName = "ScreenTranslator"; const QString appName = "ScreenTranslator";
const QString companyName = "Gres"; const QString companyName = "Gres";

64
SettingsEditor.cpp
View File

@ -7,43 +7,38 @@
#include "Settings.h" #include "Settings.h"
SettingsEditor::SettingsEditor(const LanguageHelper &dictionary, QWidget *parent) : SettingsEditor::SettingsEditor (const LanguageHelper &dictionary, QWidget *parent) :
QDialog(parent), QDialog (parent),
ui(new Ui::SettingsEditor), dictionary_ (dictionary), ui (new Ui::SettingsEditor), dictionary_ (dictionary),
buttonGroup_ (new QButtonGroup (this)) buttonGroup_ (new QButtonGroup (this)) {
{ ui->setupUi (this);
ui->setupUi(this);
buttonGroup_->addButton (ui->trayRadio, 0); buttonGroup_->addButton (ui->trayRadio, 0);
buttonGroup_->addButton (ui->dialogRadio, 1); buttonGroup_->addButton (ui->dialogRadio, 1);
connect (ui->tessdataButton, SIGNAL (clicked ()), SLOT (openTessdataDialog ())); connect (ui->tessdataButton, SIGNAL (clicked ()), SLOT (openTessdataDialog ()));
connect (ui->tessdataEdit, SIGNAL (textChanged (const QString&)), connect (ui->tessdataEdit, SIGNAL (textChanged (const QString &)),
SLOT (initOcrLangCombo (const QString&))); SLOT (initOcrLangCombo (const QString &)));
ui->translateLangCombo->addItems (dictionary_.translateLanguagesUi ()); ui->translateLangCombo->addItems (dictionary_.translateLanguagesUi ());
loadSettings (); loadSettings ();
loadState (); loadState ();
} }
SettingsEditor::~SettingsEditor() SettingsEditor::~SettingsEditor () {
{
saveState (); saveState ();
delete ui; delete ui;
} }
void SettingsEditor::done(int result) void SettingsEditor::done (int result) {
{ if (result == QDialog::Accepted) {
if (result == QDialog::Accepted)
{
saveSettings (); saveSettings ();
emit settingsEdited (); emit settingsEdited ();
} }
QDialog::done (result); QDialog::done (result);
} }
void SettingsEditor::saveSettings() const void SettingsEditor::saveSettings () const {
{
QSettings settings; QSettings settings;
settings.beginGroup (settings_names::guiGroup); settings.beginGroup (settings_names::guiGroup);
settings.setValue (settings_names::captureHotkey, ui->captureEdit->text ()); settings.setValue (settings_names::captureHotkey, ui->captureEdit->text ());
@ -69,65 +64,58 @@ void SettingsEditor::saveSettings() const
settings.endGroup (); settings.endGroup ();
} }
void SettingsEditor::openTessdataDialog() void SettingsEditor::openTessdataDialog () {
{
QString path = QFileDialog::getExistingDirectory (this, tr ("Путь к tessdata")); QString path = QFileDialog::getExistingDirectory (this, tr ("Путь к tessdata"));
if (path.isEmpty ()) if (path.isEmpty ()) {
{
return; return;
} }
QDir dir (path); QDir dir (path);
if (dir.dirName () == QString ("tessdata")) if (dir.dirName () == QString ("tessdata")) {
{
dir.cdUp (); dir.cdUp ();
} }
ui->tessdataEdit->setText (dir.path ()); ui->tessdataEdit->setText (dir.path ());
} }
void SettingsEditor::loadSettings() void SettingsEditor::loadSettings () {
{
#define GET(FIELD) settings.value (settings_names::FIELD, settings_values::FIELD) #define GET(FIELD) settings.value (settings_names::FIELD, settings_values::FIELD)
QSettings settings; QSettings settings;
settings.beginGroup (settings_names::guiGroup); settings.beginGroup (settings_names::guiGroup);
ui->captureEdit->setText (GET(captureHotkey).toString ()); ui->captureEdit->setText (GET (captureHotkey).toString ());
ui->repeatEdit->setText (GET(repeatHotkey).toString ()); ui->repeatEdit->setText (GET (repeatHotkey).toString ());
ui->clipboardEdit->setText (GET(clipboardHotkey).toString ()); ui->clipboardEdit->setText (GET (clipboardHotkey).toString ());
QAbstractButton* button = buttonGroup_->button (GET(resultShowType).toInt ()); QAbstractButton *button = buttonGroup_->button (GET (resultShowType).toInt ());
Q_CHECK_PTR (button); Q_CHECK_PTR (button);
button->setChecked (true); button->setChecked (true);
settings.endGroup (); settings.endGroup ();
settings.beginGroup (settings_names::recogntionGroup); settings.beginGroup (settings_names::recogntionGroup);
ui->tessdataEdit->setText (GET(tessDataPlace).toString ()); ui->tessdataEdit->setText (GET (tessDataPlace).toString ());
QString ocrLanguage = dictionary_.ocrCodeToUi (GET(ocrLanguage).toString ()); QString ocrLanguage = dictionary_.ocrCodeToUi (GET (ocrLanguage).toString ());
ui->ocrLangCombo->setCurrentText (ocrLanguage); ui->ocrLangCombo->setCurrentText (ocrLanguage);
ui->imageScaleSpin->setValue (GET(imageScale).toInt ()); ui->imageScaleSpin->setValue (GET (imageScale).toInt ());
settings.endGroup (); settings.endGroup ();
settings.beginGroup (settings_names::translationGroup); settings.beginGroup (settings_names::translationGroup);
QString trLanguage = dictionary_.translateCodeToUi (GET(translationLanguage).toString ()); QString trLanguage = dictionary_.translateCodeToUi (GET (translationLanguage).toString ());
ui->translateLangCombo->setCurrentText (trLanguage); ui->translateLangCombo->setCurrentText (trLanguage);
settings.endGroup (); settings.endGroup ();
#undef GET #undef GET
} }
void SettingsEditor::saveState() const void SettingsEditor::saveState () const {
{
QSettings settings; QSettings settings;
settings.beginGroup (settings_names::guiGroup); settings.beginGroup (settings_names::guiGroup);
settings.setValue (objectName () + "_" + settings_names::geometry, saveGeometry ()); settings.setValue (objectName () + "_" + settings_names::geometry, saveGeometry ());
} }
void SettingsEditor::loadState() void SettingsEditor::loadState () {
{
QSettings settings; QSettings settings;
settings.beginGroup (settings_names::guiGroup); settings.beginGroup (settings_names::guiGroup);
restoreGeometry (settings.value (objectName () + "_" + settings_names::geometry).toByteArray ()); restoreGeometry (settings.value (objectName () + "_" + settings_names::geometry).toByteArray ());
} }
void SettingsEditor::initOcrLangCombo(const QString &path) void SettingsEditor::initOcrLangCombo (const QString &path) {
{
ui->ocrLangCombo->clear (); ui->ocrLangCombo->clear ();
ui->ocrLangCombo->addItems (dictionary_.availableOcrLanguagesUi (path)); ui->ocrLangCombo->addItems (dictionary_.availableOcrLanguagesUi (path));
} }

13
SettingsEditor.h
View File

@ -10,13 +10,12 @@ namespace Ui {
} }
class LanguageHelper; class LanguageHelper;
class SettingsEditor : public QDialog class SettingsEditor : public QDialog {
{
Q_OBJECT Q_OBJECT
public: public:
explicit SettingsEditor(const LanguageHelper& dictionary, QWidget *parent = 0); explicit SettingsEditor (const LanguageHelper &dictionary, QWidget *parent = 0);
~SettingsEditor(); ~SettingsEditor ();
signals: signals:
void settingsEdited (); void settingsEdited ();
@ -27,7 +26,7 @@ class SettingsEditor : public QDialog
private slots: private slots:
void saveSettings () const; void saveSettings () const;
void openTessdataDialog (); void openTessdataDialog ();
void initOcrLangCombo (const QString& path); void initOcrLangCombo (const QString &path);
private: private:
void loadSettings (); void loadSettings ();
@ -36,8 +35,8 @@ class SettingsEditor : public QDialog
private: private:
Ui::SettingsEditor *ui; Ui::SettingsEditor *ui;
const LanguageHelper& dictionary_; const LanguageHelper &dictionary_;
QButtonGroup* buttonGroup_; QButtonGroup *buttonGroup_;
}; };
#endif // SETTINGSEDITOR_H #endif // SETTINGSEDITOR_H

2
StAssert.h
View File

@ -7,7 +7,7 @@
# if defined(ST_NO_ASSERT) # if defined(ST_NO_ASSERT)
# define ST_ASSERT(CONDITION) # define ST_ASSERT(CONDITION)
# else # else
# define ST_ASSERT(CONDITION) assert(CONDITION) # define ST_ASSERT(CONDITION) assert (CONDITION)
# endif # endif
#endif #endif

64
Translator.cpp
View File

@ -12,32 +12,29 @@
#include "GoogleWebTranslator.h" #include "GoogleWebTranslator.h"
#include "StAssert.h" #include "StAssert.h"
namespace namespace {
{
const QString translateBaseUrl = "http://translate.google.com/translate_a/" const QString translateBaseUrl = "http://translate.google.com/translate_a/"
"t?client=t&text=%1&sl=%2&tl=%3"; "t?client=t&text=%1&sl=%2&tl=%3";
} }
Translator::Translator(QObject *parent) : Translator::Translator (QObject *parent) :
QObject(parent), QObject (parent),
network_ (this), network_ (this),
useAlternativeTranslation_ (false) useAlternativeTranslation_ (false) {
{ connect (&network_, SIGNAL (finished (QNetworkReply *)),
connect (&network_, SIGNAL (finished (QNetworkReply*)), SLOT (replyFinished (QNetworkReply *)));
SLOT (replyFinished (QNetworkReply*)));
GoogleWebTranslator* googleWeb = new GoogleWebTranslator; GoogleWebTranslator *googleWeb = new GoogleWebTranslator;
connect (this, SIGNAL (translateAlternative (ProcessingItem)), connect (this, SIGNAL (translateAlternative (ProcessingItem)),
googleWeb, SLOT (translate (ProcessingItem))); googleWeb, SLOT (translate (ProcessingItem)));
connect (googleWeb, SIGNAL (translated (ProcessingItem, bool)), connect (googleWeb, SIGNAL (translated (ProcessingItem, bool)),
this, SLOT (translatedAlternative(ProcessingItem, bool))); this, SLOT (translatedAlternative (ProcessingItem, bool)));
connect (googleWeb, SIGNAL (error (QString)), this, SIGNAL (error (QString))); connect (googleWeb, SIGNAL (error (QString)), this, SIGNAL (error (QString)));
applySettings (); applySettings ();
} }
void Translator::applySettings() void Translator::applySettings () {
{
QSettings settings; QSettings settings;
settings.beginGroup (settings_names::translationGroup); settings.beginGroup (settings_names::translationGroup);
translationLanguage_ = settings.value (settings_names::translationLanguage, translationLanguage_ = settings.value (settings_names::translationLanguage,
@ -46,72 +43,61 @@ void Translator::applySettings()
settings_values::sourceLanguage).toString (); settings_values::sourceLanguage).toString ();
} }
void Translator::translate(ProcessingItem item) void Translator::translate (ProcessingItem item) {
{
if (useAlternativeTranslation_) { if (useAlternativeTranslation_) {
emit translateAlternative(item); emit translateAlternative (item);
return; return;
} }
ST_ASSERT (!item.recognized.isEmpty ()); ST_ASSERT (!item.recognized.isEmpty ());
QString sourceLanguage = item.sourceLanguage.isEmpty () ? sourceLanguage_ : QString sourceLanguage = item.sourceLanguage.isEmpty () ? sourceLanguage_ :
item.sourceLanguage; item.sourceLanguage;
if (translationLanguage_.isEmpty () || sourceLanguage.isEmpty ()) if (translationLanguage_.isEmpty () || sourceLanguage.isEmpty ()) {
{
emit error (tr ("Неверные парметры для перевода.")); emit error (tr ("Неверные парметры для перевода."));
return; return;
} }
QUrl url (translateBaseUrl.arg (item.recognized, sourceLanguage, translationLanguage_)); QUrl url (translateBaseUrl.arg (item.recognized, sourceLanguage, translationLanguage_));
QNetworkReply* reply = network_.get (QNetworkRequest (url)); QNetworkReply *reply = network_.get (QNetworkRequest (url));
items_.insert (reply, item); items_.insert (reply, item);
} }
void Translator::translatedAlternative(ProcessingItem item, bool success) void Translator::translatedAlternative (ProcessingItem item, bool success) {
{ if (success) {
if (success) emit translated (item);
{
emit translated(item);
} }
else else {
{
emit error (tr ("Ошибка альтернативного перевода текста: %1").arg (item.recognized)); emit error (tr ("Ошибка альтернативного перевода текста: %1").arg (item.recognized));
} }
} }
void Translator::replyFinished(QNetworkReply* reply) void Translator::replyFinished (QNetworkReply *reply) {
{
ST_ASSERT (items_.contains (reply)); ST_ASSERT (items_.contains (reply));
ProcessingItem item = items_.take (reply); ProcessingItem item = items_.take (reply);
ST_ASSERT (reply->isFinished ()); ST_ASSERT (reply->isFinished ());
if (reply->error () != QNetworkReply::NoError) if (reply->error () != QNetworkReply::NoError) {
{
useAlternativeTranslation_ = true; useAlternativeTranslation_ = true;
emit translateAlternative(item); emit translateAlternative (item);
reply->deleteLater (); reply->deleteLater ();
return; return;
} }
QByteArray data = reply->readAll (); QByteArray data = reply->readAll ();
reply->deleteLater (); reply->deleteLater ();
while (data.indexOf (",,") != -1)//make json valid while (data.indexOf (",,") != -1) {//make json valid
{
data.replace (",,", ","); data.replace (",,", ",");
} }
QJsonParseError parseError; QJsonParseError parseError;
QJsonDocument document = QJsonDocument::fromJson (data, &parseError); QJsonDocument document = QJsonDocument::fromJson (data, &parseError);
if (document.isEmpty ()) if (document.isEmpty ()) {
{
useAlternativeTranslation_ = true; useAlternativeTranslation_ = true;
emit translateAlternative(item); emit translateAlternative (item);
return; return;
} }
QJsonArray answerArray = document.array (); QJsonArray answerArray = document.array ();
QJsonArray fullTranslation = answerArray.first ().toArray (); QJsonArray fullTranslation = answerArray.first ().toArray ();
QString translation = ""; QString translation = "";
foreach (QJsonValue part, fullTranslation) foreach (QJsonValue part, fullTranslation) {
{
QJsonArray partTranslation = part.toArray (); QJsonArray partTranslation = part.toArray ();
if (partTranslation.isEmpty ()) if (partTranslation.isEmpty ()) {
{
continue; continue;
} }
translation += partTranslation.at (0).toString (); translation += partTranslation.at (0).toString ();

10
Translator.h
View File

@ -5,11 +5,11 @@
#include "ProcessingItem.h" #include "ProcessingItem.h"
class Translator : public QObject class Translator : public QObject {
{
Q_OBJECT Q_OBJECT
public: public:
explicit Translator(QObject *parent = 0); explicit Translator (QObject *parent = 0);
signals: signals:
void translated (ProcessingItem item); void translated (ProcessingItem item);
@ -22,13 +22,13 @@ class Translator : public QObject
void applySettings (); void applySettings ();
private slots: private slots:
void replyFinished (QNetworkReply* reply); void replyFinished (QNetworkReply *reply);
private: private:
QNetworkAccessManager network_; QNetworkAccessManager network_;
QString translationLanguage_; QString translationLanguage_;
QString sourceLanguage_; QString sourceLanguage_;
QHash<QNetworkReply*, ProcessingItem> items_; QHash<QNetworkReply *, ProcessingItem> items_;
bool useAlternativeTranslation_; bool useAlternativeTranslation_;
}; };

12
main.cpp
View File

@ -4,9 +4,8 @@
#include <Manager.h> #include <Manager.h>
#include <Settings.h> #include <Settings.h>
int main(int argc, char *argv[]) int main (int argc, char *argv[]) {
{ QApplication a (argc, argv);
QApplication a(argc, argv);
a.setQuitOnLastWindowClosed (false); a.setQuitOnLastWindowClosed (false);
a.setApplicationName (settings_values::appName); a.setApplicationName (settings_values::appName);
a.setOrganizationName (settings_values::companyName); a.setOrganizationName (settings_values::companyName);
@ -14,12 +13,11 @@ int main(int argc, char *argv[])
QTranslator translator; QTranslator translator;
// Set default to english. // Set default to english.
if (translator.load (QLocale::system (), "translation", "_", ":/translations") || if (translator.load (QLocale::system (), "translation", "_", ":/translations") ||
translator.load (":/translations/translation_en")) translator.load (":/translations/translation_en")) {
{ a.installTranslator (&translator);
a.installTranslator(&translator);
} }
Manager manager; Manager manager;
return a.exec(); return a.exec ();
} }

1578
uncrustify.cfg Normal file
View File

File diff suppressed because it is too large Load Diff