(QFont::PreferFullHinting));
_fontHinting->setCurrentIndex(0);
fontDetailsLayout->addWidget(new QLabel(tr("Size:")));
fontDetailsLayout->addWidget(_fontSizeSelector);
fontDetailsLayout->addWidget(new QLabel(tr("Weight:")));
fontDetailsLayout->addWidget(_fontWeightSelector);
fontDetailsLayout->addWidget(new QLabel(tr("Hinting:")));
fontDetailsLayout->addWidget(_fontHinting);
fontConverterLayout->addWidget(new QLabel(tr("Characters to convert:")));
_fontCharacters = new QPlainTextEdit();
_fontCharacters->setFixedHeight(100);
_fontCharacters->setSizePolicy(QSizePolicy::Preferred, QSizePolicy::Minimum);
_fontCharacters->setWordWrapMode(QTextOption::WrapAnywhere);
_fontCharacters->setPlainText("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789.,:;!?()+-=\"'<>");
_fontCharacters->setReadOnly(true);
fontConverterLayout->addWidget(_fontCharacters);
connect(_fontCharacters, &QPlainTextEdit::textChanged, this, &MainWindow::onCharactersChanged);
auto previewSplittter = new QSplitter(Qt::Vertical);
previewSplittter->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
previewSplittter->setChildrenCollapsible(false);
mainLayout->addWidget(previewSplittter);
_bitmapPanel = new BitmapPanel();
previewSplittter->addWidget(_bitmapPanel);
auto codePanel = new QWidget();
codePanel->setMinimumHeight(200);
auto codeLayout = new QVBoxLayout(codePanel);
codeLayout->setContentsMargins(16, 4, 16, 16);
codeLayout->setSpacing(4);
codeLayout->addWidget(new QLabel(tr("Generated Code:")));
_codePreview = new QPlainTextEdit();
_codePreview->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Expanding);
_codePreview->setReadOnly(true);
_codePreview->setWordWrapMode(QTextOption::NoWrap);
codeLayout->addWidget(_codePreview);
const auto monospaceFont = gApp()->monospaceFont();
_codePreview->setFont(monospaceFont);
_fontCharacters->setFont(monospaceFont);
auto codeActions = new QFrame();
auto codeActionsLayout = new QHBoxLayout(codeActions);
codeActionsLayout->setContentsMargins(0, 0, 0, 0);
codeActionsLayout->setSpacing(4);
codeActionsLayout->addStretch();
auto copyCodeButton = new QPushButton();
copyCodeButton->setText(tr("Copy Code"));
codeActionsLayout->addWidget(copyCodeButton);
connect(copyCodeButton, &QPushButton::clicked, [=]{
qApp->clipboard()->setText(_codePreview->toPlainText());
});
codeLayout->addWidget(codeActions);
previewSplittter->addWidget(codePanel);
previewSplittter->setStretchFactor(0, 4);
previewSplittter->setStretchFactor(1, 1);
connect(_formatSelector, &QComboBox::currentIndexChanged, this, &MainWindow::onFormatChanged);
connect(_fontSelector, &QFontComboBox::currentFontChanged, this, &MainWindow::onFontChanged);
connect(_fontSizeSelector, &QSpinBox::valueChanged, this, &MainWindow::onFontChanged);
connect(_fontWeightSelector, &QComboBox::currentIndexChanged, this, &MainWindow::onFontChanged);
connect(_fontHinting, &QComboBox::currentIndexChanged, this, &MainWindow::onFontChanged);
connect(_bitmapPanel, &BitmapPanel::selectedCharacterChanged, this, &MainWindow::onSelectedCharacterChanged);
}
void MainWindow::initializeMenu()
{
auto menuFile = menuBar()->addMenu(tr("File"));
auto actionLoadBitmap = menuFile->addAction(tr("Load Bitmap..."));
actionLoadBitmap->setShortcut(QKeySequence("Ctrl+O"));
connect(actionLoadBitmap, &QAction::triggered, this, &MainWindow::onLoadBitmap);
auto actionQuit = menuFile->addAction(tr("Quit"));
connect(actionQuit, &QAction::triggered, [=]{
qApp->quit();
});
auto menuEdit = menuBar()->addMenu(tr("Edit"));
menuEdit->addAction(tr("Cut"), [=]{
QMetaObject::invokeMethod(focusWidget(), "cut");
}, QKeySequence("Ctrl+X"));
menuEdit->addAction(tr("Copy"), [=]{
QMetaObject::invokeMethod(focusWidget(), "copy");
}, QKeySequence("Ctrl+C"));
menuEdit->addAction(tr("Paste"), [=]{
QMetaObject::invokeMethod(focusWidget(), "paste");
}, QKeySequence("Ctrl+V"));
auto menuHelp = menuBar()->addMenu(tr("Help"));
auto actionAbout = menuHelp->addAction(tr("About..."));
menuHelp->addAction(tr("Lucky Resistor..."), []{
QDesktopServices::openUrl(QUrl("https://luckyresistor.me/"));
});
menuHelp->addAction(tr("Project Page..."), []{
QDesktopServices::openUrl(QUrl("https://luckyresistor.me/applications/micropython-bitmap-tool/"));
});
connect(actionAbout, &QAction::triggered, [=]{
QMessageBox::about(this, tr("Micropython Bitmap Tool by Lucky Resistor"),
tr("Micropython Bitmap Tool
"
"Copyright (c)2021 by Lucky Resistor
"
"Version %1
"
"License
"
"This program is free software: you can redistribute it and/or modify "
"it under the terms of the GNU General Public License as published by "
"the Free Software Foundation, either version 3 of the License, or "
"(at your option) any later version.
"
"This program is distributed in the hope that it will be useful, "
"but WITHOUT ANY WARRANTY; without even the implied warranty of "
"MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the "
"GNU General Public License for more details.
"
"You should have received a copy of the GNU General Public License "
"along with this program. If not, see https://www.gnu.org/licenses/.").arg(qApp->applicationVersion()));
});
auto actionAboutQt = menuHelp->addAction(tr("Information About Qt..."));
connect(actionAboutQt, &QAction::triggered, [=]{
QMessageBox::aboutQt(this);
});
}
void MainWindow::loadSettings()
{
QSettings settings;
restoreGeometry(settings.value("mainWindow.geometry").toByteArray());
restoreState(settings.value("mainWindow.state").toByteArray());
_formatSelector->setCurrentIndex(settings.value("format.index").toInt(0));
_currentFont = QFont(settings.value("font.family", "Arial").toString());
_currentFont.setPixelSize(settings.value("font.size", 12).toInt());
_currentFont.setWeight(static_cast(settings.value("font.weight", 500).toInt()));
_fontSelector->setCurrentFont(_currentFont);
_fontSizeSelector->setValue(_currentFont.pixelSize());
const int index = _fontWeightSelector->findData(static_cast(_currentFont.weight()));
if (index >= 0) {
_fontWeightSelector->setCurrentIndex(index);
} else {
_fontWeightSelector->setCurrentIndex(3); // normal
}
_fontHinting->setCurrentIndex(settings.value("font.hinting", 0).toInt());
}
void MainWindow::saveSettings()
{
QSettings settings;
settings.setValue("mainWindow.geometry", saveGeometry());
settings.setValue("mainWindow.state", saveState());
settings.setValue("format.index", _formatSelector->currentIndex());
settings.setValue("font.family", _currentFont.family());
settings.setValue("font.size", _currentFont.pixelSize());
settings.setValue("font.weight", static_cast(_currentFont.weight()));
settings.setValue("font.hinting", _fontHinting->currentIndex());
}
Converter *MainWindow::selectedConverter() const
{
auto converter = _converterList.value(_formatSelector->currentIndex());
if (converter == nullptr) {
converter = _converterList.first();
}
return converter;
}
void MainWindow::updateInfoBox()
{
QString text;
QTextStream ts(&text);
if (selectedConverter()->mode() == Converter::Mode::Bitmap) {
ts << "";
ts << "Bitmap Size: " << _currentImage.width() << "x" << _currentImage.height() << "
";
ts << "Bit Depth: " << _currentImage.depth() << "
";
ts << "Color Format: ";
switch (_currentImage.pixelFormat().colorModel()) {
case QPixelFormat::RGB: ts << "RGB"; break;
case QPixelFormat::BGR: ts << "BGR"; break;
case QPixelFormat::Indexed: ts << "Indexed"; break;
case QPixelFormat::Grayscale: ts << "Grayscale"; break;
case QPixelFormat::CMYK: ts << "CMYK"; break;
case QPixelFormat::HSL: ts << "HSL"; break;
case QPixelFormat::HSV: ts << "HSV"; break;
case QPixelFormat::YUV: ts << "YUV"; break;
case QPixelFormat::Alpha: ts << "Alpha"; break;
}
ts << "
";
const auto gs = selectedConverter()->generatedSize(_currentImage.size(), createParameterMap());
ts << "Generated Size: " << gs.width() << "x" << gs.height() << "
";
_bitmapInfo->setText(text);
} else {
ts << "";
ts << "Family: " << _currentFont.family() << "
";
ts << "Weight: ";
switch (_currentFont.weight()) {
case QFont::Thin: ts << tr("Thin"); break;
case QFont::ExtraLight: ts << tr("Extra Light"); break;
case QFont::Light: ts << tr("Light"); break;
case QFont::Normal: ts << tr("Normal"); break;
case QFont::Medium: ts << tr("Medium"); break;
case QFont::DemiBold: ts << tr("Demi Bold"); break;
case QFont::Bold: ts << tr("Bold"); break;
case QFont::ExtraBold: ts << tr("Extra Bold"); break;
case QFont::Black: ts << tr("Black"); break;
}
ts << "
";
ts << "Pixel Size: " << _currentFont.pixelSize() << "
";
ts << "
";
_fontInfo->setText(text);
}
}
void MainWindow::updateCode()
{
QString code;
if (selectedConverter()->mode() == Converter::Mode::Bitmap) {
auto bitmapConverter = static_cast(selectedConverter());
if (!_currentImage.isNull()) {
code = bitmapConverter->generateCode(_currentImage, QVariantMap());
}
} else {
auto fontConverter = static_cast(selectedConverter());
code = fontConverter->generateCode(_currentFont, createParameterMap());
}
_codePreview->setPlainText(code);
}
void MainWindow::updateParameters()
{
auto converter = selectedConverter();
if (converter == nullptr) {
return;
}
// Replace the current parameter definition.
_displayedParameters = converter->createParameterDefinition();
// Remove the previous UI
while (_parameterLayout->count() > 0) {
auto item = _parameterLayout->takeAt(0);
delete item;
}
for (auto w : _parameterFrame->findChildren()) {
w->deleteLater();
}
// Build the new parameter UI.
if (_displayedParameters->parameterList().isEmpty()) {
auto label = new QLabel();
label->setText(tr("No Parameters"));
_parameterLayout->addWidget(label);
} else {
for (const auto ¶meter : _displayedParameters->parameterList()) {
auto pw = parameterFactory.createWidget(parameter);
pw->setSizePolicy(QSizePolicy::Minimum, QSizePolicy::Minimum);
pw->setObjectName(parameter->identifier());
_parameterLayout->addRow(parameter->label() + ":", pw);
connect(pw, &ParameterWidget::valueChanged, this, &MainWindow::onParameterChanged);
}
}
auto stretchItem = new QWidget();
stretchItem->setFixedWidth(10);
stretchItem->setSizePolicy(QSizePolicy::Fixed, QSizePolicy::Expanding);
_parameterLayout->addRow(stretchItem);
}
QVariantMap MainWindow::createParameterMap() const
{
QVariantMap result;
result["characters"] = _fontCharacters->toPlainText();
result["font"] = _currentFont;
result["char"] = _bitmapPanel->selectedCharacter();
for (auto pw : _parameterFrame->findChildren()) {
result[pw->objectName()] = pw->value();
}
return result;
}
void MainWindow::onLoadBitmap()
{
QSettings settings;
auto lastDir = settings.value("bitmap.lastDir").toString();
auto fileName = QFileDialog::getOpenFileName(
this,
tr("Open Bitmap"),
lastDir,
tr("Images (*.png *.jpg *.jpeg *.gif *.pbm *.pgm *.ppm *.xbm *.xpm *.bpm)"));
if (fileName.isEmpty()) {
return;
}
QFileInfo fileInfo(fileName);
settings.setValue("bitmap.lastDir", fileInfo.absoluteDir().path());
QImage newImage;
if (!newImage.load(fileName)) {
QMessageBox::warning(this, tr("Loading Image Failed"),
tr("Failed to load the image
"
"Could not load the specified image file. "
"Make sure the image is in a supported format.
"));
return;
}
if (newImage.width() > 0x100 || newImage.height() > 0x100) {
QMessageBox::warning(this, tr("Image is Too Large"),
tr("Image is Too Large
"
"One dimension of the loaded image is larger than "
"256 pixel. This software is designed for small bitmaps.
"));
return;
}
_currentImage = newImage;
_bitmapPanel->setImage(newImage);
_bitmapPanel->setConverter(selectedConverter());
updateInfoBox();
updateCode();
}
void MainWindow::onFormatChanged()
{
const auto converter = selectedConverter();
_bitmapPanel->setConverter(converter);
if (converter->mode() == Converter::Mode::Bitmap) {
_bitmapConverterFrame->setVisible(true);
_fontConverterFrame->setVisible(false);
} else {
_bitmapConverterFrame->setVisible(false);
_fontConverterFrame->setVisible(true);
}
updateParameters();
updateInfoBox();
updateCode();
_bitmapPanel->setParameter(createParameterMap());
onSelectedCharacterChanged(_bitmapPanel->selectedCharacter());
}
void MainWindow::onFontChanged()
{
_currentFont = _fontSelector->currentFont();
_currentFont.setWeight(static_cast(_fontWeightSelector->currentData().toInt()));
_currentFont.setPixelSize(_fontSizeSelector->value());
const auto hintingPreferences = static_cast(_fontHinting->currentData().toInt());
_currentFont.setHintingPreference(hintingPreferences);
updateInfoBox();
updateCode();
_bitmapPanel->setParameter(createParameterMap());
onSelectedCharacterChanged(_bitmapPanel->selectedCharacter());
}
void MainWindow::onCharactersChanged()
{
auto characters = _fontCharacters->toPlainText();
_bitmapPanel->setCharacters(characters);
_bitmapPanel->setConverter(selectedConverter());
_bitmapPanel->setParameter(createParameterMap());
onSelectedCharacterChanged(_bitmapPanel->selectedCharacter());
}
void MainWindow::onSelectedCharacterChanged(QChar c)
{
auto converter = selectedConverter();
if (converter == nullptr) {
return;
}
if (converter->mode() == Converter::Mode::Font) {
auto fontConverter = static_cast(converter);
auto newImage = fontConverter->generateImage(_currentFont, c, createParameterMap());
_currentImage = newImage;
_bitmapPanel->setImage(newImage);
_bitmapPanel->setConverter(selectedConverter());
_bitmapPanel->setParameter(createParameterMap());
}
}
void MainWindow::onParameterChanged()
{
_bitmapPanel->setParameter(createParameterMap());
onSelectedCharacterChanged(_bitmapPanel->selectedCharacter());
}
void MainWindow::closeEvent(QCloseEvent *event)
{
saveSettings();
QMainWindow::closeEvent(event);
}