629 lines
18 KiB
C++
629 lines
18 KiB
C++
|
|
|
|
#include "toonzqt/infoviewer.h"
|
|
#include "toonzqt/intfield.h"
|
|
#include "tsystem.h"
|
|
#include "tlevel.h"
|
|
#include "tpalette.h"
|
|
#include "tlevel_io.h"
|
|
#include "tsound_io.h"
|
|
#include "tiio.h"
|
|
#include "tstream.h"
|
|
#include "ttoonzimage.h"
|
|
#include "trasterimage.h"
|
|
#include "tvectorimage.h"
|
|
#include "toonz/toonzscene.h"
|
|
#include "toonzqt/gutil.h"
|
|
#include "toonzqt/dvdialog.h"
|
|
#include "toutputproperties.h"
|
|
#include "toonz/sceneproperties.h"
|
|
#include "toonz/tcamera.h"
|
|
#include "toonz/levelset.h"
|
|
#include "tcontenthistory.h"
|
|
#include "tfiletype.h"
|
|
#include <QSlider>
|
|
#include <QLabel>
|
|
#include <QTextEdit>
|
|
#include <QDateTime>
|
|
|
|
using namespace DVGui;
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
class InfoViewerImp {
|
|
public:
|
|
enum {
|
|
eFullpath = 0,
|
|
eFileType,
|
|
eFrames,
|
|
eOwner,
|
|
eSize,
|
|
eCreated,
|
|
eModified,
|
|
eLastAccess,
|
|
eImageSize,
|
|
eSaveBox,
|
|
eBitsSample,
|
|
eSamplePixel,
|
|
eDpi,
|
|
eOrientation,
|
|
eCompression,
|
|
eQuality,
|
|
eSmoothing,
|
|
eCodec,
|
|
eAlphaChannel,
|
|
eByteOrdering,
|
|
eHPos,
|
|
ePalettePages,
|
|
ePaletteStyles,
|
|
eCamera,
|
|
eCameraDpi,
|
|
eFrameCount,
|
|
eLevelCount,
|
|
eOutputPath,
|
|
eEndianess,
|
|
|
|
// sound info
|
|
eLength,
|
|
eChannels,
|
|
eSampleRate,
|
|
eSampleSize,
|
|
eHowMany
|
|
};
|
|
|
|
TFilePath m_path;
|
|
TLevelP m_level;
|
|
std::vector<TFrameId> m_fids;
|
|
QStringList m_formats;
|
|
int m_currentIndex;
|
|
int m_frameCount;
|
|
TPalette *m_palette;
|
|
QLabel m_framesLabel;
|
|
IntField m_framesSlider;
|
|
std::vector<std::pair<QLabel *, QLabel *>> m_labels;
|
|
QLabel m_historyLabel;
|
|
QTextEdit m_history;
|
|
Separator m_separator1, m_separator2;
|
|
void setFileInfo(const TFileStatus &status);
|
|
void setImageInfo();
|
|
void setSoundInfo();
|
|
// void cleanFileInfo();
|
|
void cleanLevelInfo();
|
|
void setToonzSceneInfo();
|
|
void setPaletteInfo();
|
|
void setGeneralFileInfo(const TFilePath &path);
|
|
QString getTypeString();
|
|
void onSliderChanged();
|
|
InfoViewerImp();
|
|
~InfoViewerImp();
|
|
void clear();
|
|
bool setLabel(TPropertyGroup *pg, int index, std::string type);
|
|
void create(int index, QString str);
|
|
void loadPalette(const TFilePath &path);
|
|
|
|
inline void setVal(int index, const QString &str) {
|
|
m_labels[index].second->setText(str);
|
|
}
|
|
|
|
public slots:
|
|
|
|
bool setItem(const TLevelP &level, TPalette *palette, const TFilePath &path);
|
|
};
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
InfoViewer::InfoViewer(QWidget *parent)
|
|
: Dialog(parent), m_imp(new InfoViewerImp()) {
|
|
setWindowTitle(tr("File Info"));
|
|
setWindowFlags(windowFlags() | Qt::WindowStaysOnTopHint);
|
|
// setAttribute(Qt::WA_DeleteOnClose);
|
|
|
|
int i;
|
|
for (i = 0; i < (int)m_imp->m_labels.size(); i++) {
|
|
addWidgets(m_imp->m_labels[i].first, m_imp->m_labels[i].second);
|
|
if (i == InfoViewerImp::eLastAccess) addWidget(&m_imp->m_separator1);
|
|
}
|
|
|
|
addWidget(&m_imp->m_separator2);
|
|
addWidget(&m_imp->m_historyLabel);
|
|
addWidget(&m_imp->m_history);
|
|
|
|
addWidgets(&m_imp->m_framesLabel, &m_imp->m_framesSlider);
|
|
|
|
connect(&m_imp->m_framesSlider, SIGNAL(valueChanged(bool)), this,
|
|
SLOT(onSliderChanged(bool)));
|
|
hide();
|
|
}
|
|
|
|
InfoViewer::~InfoViewer() {}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewer::hideEvent(QHideEvent *) { m_imp->m_level = TLevelP(); }
|
|
|
|
//----------------------------------------------------------------
|
|
void InfoViewer::onSliderChanged(bool) { m_imp->onSliderChanged(); }
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewerImp::onSliderChanged() {
|
|
if (m_framesSlider.getValue() - 1 == m_currentIndex) return;
|
|
|
|
m_currentIndex = m_framesSlider.getValue() - 1;
|
|
setImageInfo();
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
namespace {
|
|
void setLabelStyle(QLabel *l) { l->setObjectName("TitleTxtLabel"); }
|
|
} // namespace
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewerImp::create(int index, QString str) {
|
|
m_labels[index] =
|
|
std::pair<QLabel *, QLabel *>(new QLabel(str), new QLabel(""));
|
|
setLabelStyle(m_labels[index].first);
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
InfoViewerImp::InfoViewerImp()
|
|
: m_palette(0)
|
|
, m_framesLabel(QObject::tr("Current Frame: "))
|
|
, m_framesSlider()
|
|
, m_history()
|
|
, m_historyLabel(QObject::tr("File History")) {
|
|
setLabelStyle(&m_framesLabel);
|
|
|
|
TLevelReader::getSupportedFormats(m_formats);
|
|
TSoundTrackReader::getSupportedFormats(m_formats);
|
|
|
|
m_labels.resize(eHowMany);
|
|
|
|
create(eFullpath, QObject::tr("Fullpath: "));
|
|
create(eFileType, QObject::tr("File Type: "));
|
|
create(eFrames, QObject::tr("Frames: "));
|
|
create(eOwner, QObject::tr("Owner: "));
|
|
create(eSize, QObject::tr("Size: "));
|
|
|
|
create(eCreated, QObject::tr("Created: "));
|
|
create(eModified, QObject::tr("Modified: "));
|
|
create(eLastAccess, QObject::tr("Last Access: "));
|
|
|
|
// level info
|
|
|
|
create(eImageSize, QObject::tr("Image Size: "));
|
|
create(eSaveBox, QObject::tr("SaveBox: "));
|
|
create(eBitsSample, QObject::tr("Bits/Sample: "));
|
|
create(eSamplePixel, QObject::tr("Sample/Pixel: "));
|
|
create(eDpi, QObject::tr("Dpi: "));
|
|
create(eOrientation, QObject::tr("Orientation: "));
|
|
create(eCompression, QObject::tr("Compression: "));
|
|
create(eQuality, QObject::tr("Quality: "));
|
|
create(eSmoothing, QObject::tr("Smoothing: "));
|
|
create(eCodec, QObject::tr("Codec: "));
|
|
create(eAlphaChannel, QObject::tr("Alpha Channel:"));
|
|
create(eByteOrdering, QObject::tr("Byte Ordering:"));
|
|
create(eHPos, QObject::tr("H Pos:"));
|
|
create(ePalettePages, QObject::tr("Palette Pages:"));
|
|
create(ePaletteStyles, QObject::tr("Palette Styles:"));
|
|
|
|
create(eCamera, QObject::tr("Camera Size: "));
|
|
create(eCameraDpi, QObject::tr("Camera Dpi: "));
|
|
create(eFrameCount, QObject::tr("Number of Frames: "));
|
|
create(eLevelCount, QObject::tr("Number of Levels: "));
|
|
create(eOutputPath, QObject::tr("Output Path: "));
|
|
create(eEndianess, QObject::tr("Endianess: "));
|
|
|
|
// sound info
|
|
create(eLength, QObject::tr("Length: "));
|
|
create(eChannels, QObject::tr("Channels: "));
|
|
create(eSampleRate, QObject::tr("Sample Rate: "));
|
|
create(eSampleSize, QObject::tr("Sample Size: "));
|
|
|
|
m_historyLabel.setStyleSheet("color: rgb(0, 0, 200);");
|
|
m_history.setStyleSheet("font-size: 12px; font-family: \"courier\";");
|
|
// m_history.setStyleSheet("font-family: \"courier\";");
|
|
m_history.setReadOnly(true);
|
|
m_history.setFixedWidth(490);
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewerImp::clear() {
|
|
int i;
|
|
|
|
for (i = 0; i < (int)m_labels.size(); i++) setVal(i, "");
|
|
|
|
m_history.clear();
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
InfoViewerImp::~InfoViewerImp() {
|
|
int i;
|
|
for (i = 0; i < (int)m_labels.size(); i++) {
|
|
delete m_labels[i].first;
|
|
delete m_labels[i].second;
|
|
}
|
|
|
|
m_labels.clear();
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewerImp::setFileInfo(const TFileStatus &status) {
|
|
// m_fPath.setText(status.
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
QString InfoViewerImp::getTypeString() {
|
|
QString ext = QString::fromStdString(m_path.getType());
|
|
|
|
if (ext == "tlv" || ext == "tzp" || ext == "tzu")
|
|
return "Smart Raster Level";
|
|
else if (ext == "pli" || ext == "svg")
|
|
return "Vector Level";
|
|
else if (ext == "mov" || ext == "avi" || ext == "3gp")
|
|
return "Movie File";
|
|
else if (ext == "tnz")
|
|
return "Tahoma2D Scene";
|
|
else if (ext == "tab")
|
|
return "Tab Scene";
|
|
else if (ext == "plt")
|
|
return "Tahoma2D Palette";
|
|
else if (ext == "wav" || ext == "aiff" || ext == "mp3")
|
|
return "Audio File";
|
|
else if (ext == "mesh")
|
|
return "Mesh Level";
|
|
else if (ext == "pic")
|
|
return "Pic File";
|
|
else if (Tiio::makeReader(ext.toStdString()))
|
|
return (m_fids.size() == 1) ? "Single Raster Image" : "Raster Level";
|
|
else if (ext == "psd")
|
|
return "Photoshop Image";
|
|
else
|
|
return "Unmanaged File Type";
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewerImp::setGeneralFileInfo(const TFilePath &path) {
|
|
QFileInfo fi = toQString(path);
|
|
assert(fi.exists());
|
|
|
|
setVal(eFullpath, fi.absoluteFilePath());
|
|
setVal(eFileType, getTypeString());
|
|
if (fi.owner() != "") setVal(eOwner, fi.owner());
|
|
setVal(eSize, fileSizeString(fi.size()));
|
|
setVal(eCreated, fi.created().toString());
|
|
setVal(eModified, fi.lastModified().toString());
|
|
setVal(eLastAccess, fi.lastRead().toString());
|
|
m_separator1.show();
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
bool InfoViewerImp::setLabel(TPropertyGroup *pg, int index, std::string type) {
|
|
TProperty *p = pg->getProperty(type);
|
|
if (!p) return false;
|
|
QString str = QString::fromStdString(p->getValueAsString());
|
|
if (dynamic_cast<TBoolProperty *>(p))
|
|
setVal(index, str == "0" ? "No" : "Yes");
|
|
else
|
|
setVal(index, str);
|
|
return true;
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewerImp::setImageInfo() {
|
|
if (m_path != TFilePath() && !m_fids.empty())
|
|
setGeneralFileInfo(m_path.getType() == "tlv" || !m_path.isLevelName()
|
|
? m_path
|
|
: m_path.withFrame(m_fids[m_currentIndex]));
|
|
|
|
assert(m_level);
|
|
|
|
setVal(eFrames, QString::number(m_level->getFrameCount()));
|
|
|
|
TLevelReaderP lr(m_path);
|
|
const TImageInfo *ii;
|
|
try {
|
|
ii = lr->getImageInfo(m_fids[m_currentIndex]);
|
|
} catch (...) {
|
|
return;
|
|
}
|
|
if (!m_fids.empty() && lr && ii) {
|
|
setVal(eImageSize,
|
|
QString::number(ii->m_lx) + " X " + QString::number(ii->m_ly));
|
|
if (ii->m_x0 <= ii->m_x1)
|
|
setVal(eSaveBox, "(" + QString::number(ii->m_x0) + ", " +
|
|
QString::number(ii->m_y0) + ", " +
|
|
QString::number(ii->m_x1) + ", " +
|
|
QString::number(ii->m_y1) + ")");
|
|
if (ii->m_bitsPerSample > 0)
|
|
setVal(eBitsSample, QString::number(ii->m_bitsPerSample));
|
|
if (ii->m_samplePerPixel > 0)
|
|
setVal(eSamplePixel, QString::number(ii->m_samplePerPixel));
|
|
// if (ii->m_dpix > 0 || ii->m_dpiy > 0)
|
|
// setVal(eDpi, "(" + QString::number(ii->m_dpix) + ", " +
|
|
// QString::number(ii->m_dpiy) + ")");
|
|
TPropertyGroup *pg = ii->m_properties;
|
|
if (pg) {
|
|
setLabel(pg, eOrientation, "Orientation");
|
|
if (!setLabel(pg, eCompression, "Compression") &&
|
|
!setLabel(pg, eCompression, "Compression Type") &&
|
|
!setLabel(pg, eCompression, "RLE-Compressed"))
|
|
setLabel(pg, eCompression, "File Compression");
|
|
setLabel(pg, eQuality, "Quality");
|
|
setLabel(pg, eSmoothing, "Smoothing");
|
|
setLabel(pg, eCodec, "Codec");
|
|
setLabel(pg, eAlphaChannel, "Alpha Channel");
|
|
setLabel(pg, eByteOrdering, "Byte Ordering");
|
|
setLabel(pg, eEndianess, "Endianess");
|
|
}
|
|
} else
|
|
m_separator1.hide();
|
|
|
|
const TContentHistory *ch = 0;
|
|
if (lr) ch = lr->getContentHistory();
|
|
|
|
if (ch) {
|
|
QString str = ch->serialize();
|
|
str = str.remove('\n');
|
|
str = str.remove(QChar(0));
|
|
str = str.replace("||", "\n");
|
|
str = str.remove('|');
|
|
m_history.setPlainText(str);
|
|
}
|
|
|
|
TImageP img = m_level->frame(m_fids[m_currentIndex]);
|
|
TToonzImageP timg = (TToonzImageP)img;
|
|
TRasterImageP rimg = (TRasterImageP)img;
|
|
TVectorImageP vimg = (TVectorImageP)img;
|
|
|
|
if (img) {
|
|
TRect r = convert(timg->getBBox());
|
|
if (r.x0 <= r.x1)
|
|
setVal(eSaveBox,
|
|
"(" + QString::number(r.x0) + ", " + QString::number(r.y0) + ", " +
|
|
QString::number(r.x1) + ", " + QString::number(r.y1) + ")");
|
|
}
|
|
|
|
// double dpix, dpiy;
|
|
|
|
if (timg) {
|
|
// setVal(eHPos, QString::number(timg->gethPos()));
|
|
// timg->getDpi(dpix, dpiy);
|
|
// setVal(eDpi,
|
|
// "(" + QString::number(dpix) + ", " + QString::number(dpiy) + ")");
|
|
TDimension dim = timg->getRaster()->getSize();
|
|
setVal(eImageSize,
|
|
QString::number(dim.lx) + " X " + QString::number(dim.ly));
|
|
m_palette = timg->getPalette();
|
|
} else if (rimg) {
|
|
/*rimg->getDpi(dpix, dpiy);
|
|
setVal(eDpi,
|
|
"(" + QString::number(dpix) + ", " + QString::number(dpiy) + ")");*/
|
|
TDimension dim = rimg->getRaster()->getSize();
|
|
setVal(eImageSize,
|
|
QString::number(dim.lx) + " X " + QString::number(dim.ly));
|
|
} else if (vimg)
|
|
m_palette = vimg->getPalette();
|
|
|
|
// TImageP img = m_level->frame(m_fids[m_currentIndex]);
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewerImp::setSoundInfo() {
|
|
if (m_path != TFilePath()) setGeneralFileInfo(m_path);
|
|
TSoundTrackP sndTrack;
|
|
try {
|
|
TSoundTrackReaderP sr(m_path);
|
|
if (sr) sndTrack = sr->load();
|
|
} catch (...) {
|
|
return;
|
|
}
|
|
if (!sndTrack) return;
|
|
|
|
int seconds = sndTrack->getDuration();
|
|
int minutes = seconds / 60;
|
|
seconds = seconds % 60;
|
|
QString label;
|
|
if (minutes > 0) label += QString::number(minutes) + " min ";
|
|
label += QString::number(seconds) + " sec";
|
|
setVal(eLength, label);
|
|
|
|
label = QString::number(sndTrack->getChannelCount());
|
|
setVal(eChannels, label);
|
|
|
|
TUINT32 sampleRate = sndTrack->getSampleRate();
|
|
label = QString::number(sampleRate / 1000) + " KHz";
|
|
setVal(eSampleRate, label);
|
|
|
|
label = QString::number(sndTrack->getBitPerSample()) + " bit";
|
|
setVal(eSampleSize, label);
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewerImp::cleanLevelInfo() {}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewer::setItem(const TLevelP &level, TPalette *palette,
|
|
const TFilePath &path) {
|
|
if (m_imp->setItem(level, palette, path))
|
|
show();
|
|
else
|
|
hide();
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewerImp::setToonzSceneInfo() {
|
|
ToonzScene scene;
|
|
try {
|
|
scene.loadNoResources(m_path);
|
|
} catch (...) {
|
|
return;
|
|
}
|
|
|
|
TCamera *cam = scene.getCurrentCamera();
|
|
if (!cam) return;
|
|
|
|
TContentHistory *ch = scene.getContentHistory();
|
|
if (ch) {
|
|
QString str = ch->serialize();
|
|
str = str.remove('\n');
|
|
str = str.remove(QChar(0));
|
|
str = str.replace("||", "\n");
|
|
str = str.remove('|');
|
|
m_history.setPlainText(str);
|
|
}
|
|
|
|
TLevelSet *set = scene.getLevelSet();
|
|
TSceneProperties *prop = scene.getProperties();
|
|
TOutputProperties *oprop = prop->getOutputProperties();
|
|
|
|
setVal(eCamera, QString::number(cam->getRes().lx) + " X " +
|
|
QString::number(cam->getRes().ly));
|
|
// setVal(eCameraDpi, QString::number(cam->getDpi().x) + ", " +
|
|
// QString::number(cam->getDpi().y));
|
|
setVal(eFrameCount, QString::number(scene.getFrameCount()));
|
|
if (set) setVal(eLevelCount, QString::number(set->getLevelCount()));
|
|
|
|
if (oprop) setVal(eOutputPath, toQString(oprop->getPath()));
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewerImp::setPaletteInfo() {
|
|
if (!m_palette) return;
|
|
|
|
setVal(ePalettePages, QString::number(m_palette->getPageCount()));
|
|
setVal(ePaletteStyles, QString::number(m_palette->getStyleCount()));
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
void InfoViewerImp::loadPalette(const TFilePath &path) {
|
|
TIStream is(path);
|
|
if (is) {
|
|
TPersist *p = 0;
|
|
is >> p;
|
|
m_palette = dynamic_cast<TPalette *>(p);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------
|
|
|
|
bool InfoViewerImp::setItem(const TLevelP &level, TPalette *palette,
|
|
const TFilePath &path) {
|
|
int i;
|
|
clear();
|
|
|
|
m_path = path;
|
|
m_level = level;
|
|
m_fids.clear();
|
|
m_currentIndex = 0;
|
|
m_palette = palette;
|
|
m_framesLabel.hide();
|
|
m_framesSlider.hide();
|
|
m_separator1.hide();
|
|
m_separator2.hide();
|
|
|
|
QString ext = QString::fromStdString(m_path.getType());
|
|
|
|
if (m_path != TFilePath() && !m_formats.contains(ext) &&
|
|
!Tiio::makeReader(m_path.getType())) {
|
|
// e' un file non di immagine (plt, tnz, ...)
|
|
assert(!m_level);
|
|
|
|
if (!TSystem::doesExistFileOrLevel(m_path)) {
|
|
DVGui::warning(QObject::tr("The file %1 does not exist.")
|
|
.arg(QString::fromStdWString(path.getWideString())));
|
|
|
|
return false;
|
|
}
|
|
|
|
setGeneralFileInfo(m_path);
|
|
|
|
if (ext == "plt") {
|
|
assert(!m_level && !m_palette);
|
|
loadPalette(m_path);
|
|
} else if (ext == "tnz")
|
|
setToonzSceneInfo();
|
|
} else if (TFileType::getInfo(m_path) == TFileType::AUDIO_LEVEL) {
|
|
setSoundInfo();
|
|
} else {
|
|
if (ext == "tlv") loadPalette(m_path.withNoFrame().withType("tpl"));
|
|
|
|
if (!m_level) {
|
|
assert(m_path != TFilePath());
|
|
TLevelReaderP lr;
|
|
try {
|
|
lr = TLevelReaderP(m_path);
|
|
} catch (...) {
|
|
return false;
|
|
}
|
|
if (lr) {
|
|
try {
|
|
m_level = lr->loadInfo();
|
|
} catch (...) {
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (m_level) {
|
|
// Image or level of images case
|
|
|
|
// TLVs are not intended as movie file here (why?). Neither are those
|
|
bool isMovieFile =
|
|
(ext != "tlv" && m_formats.contains(ext) && !m_path.isLevelName());
|
|
|
|
m_frameCount = m_level->getFrameCount();
|
|
assert(m_frameCount);
|
|
m_fids.resize(m_frameCount);
|
|
TLevel::Iterator it = m_level->begin();
|
|
for (i = 0; it != m_level->end(); ++it, ++i) m_fids[i] = it->first;
|
|
|
|
if (m_frameCount > 1 && !isMovieFile) {
|
|
m_framesSlider.setRange(1, m_frameCount);
|
|
m_framesSlider.setValue(0);
|
|
m_framesSlider.show();
|
|
m_framesLabel.show();
|
|
}
|
|
|
|
setImageInfo();
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
if (m_palette) setPaletteInfo();
|
|
|
|
for (i = 0; i < (int)m_labels.size(); i++)
|
|
if (m_labels[i].second->text() == "")
|
|
m_labels[i].first->hide(), m_labels[i].second->hide();
|
|
else
|
|
m_labels[i].first->show(), m_labels[i].second->show();
|
|
|
|
if (m_history.toPlainText() == "") {
|
|
m_separator2.hide();
|
|
m_historyLabel.hide();
|
|
m_history.hide();
|
|
} else {
|
|
m_separator2.show();
|
|
m_historyLabel.show();
|
|
m_history.show();
|
|
}
|
|
|
|
return true;
|
|
}
|