571 lines
16 KiB
C++
571 lines
16 KiB
C++
|
|
|
|
#include "thumbnailviewer.h"
|
|
#include "thumbnail.h"
|
|
#include "tfilepath.h"
|
|
#include "tsystem.h"
|
|
|
|
#include "tw/textfield.h"
|
|
#include "tw/colors.h"
|
|
#include "tw/event.h"
|
|
#include "tw/dragdrop.h"
|
|
#include "tw/keycodes.h"
|
|
#include "tw/mainshell.h"
|
|
|
|
#include "tw/message.h"
|
|
|
|
using namespace TwConsts;
|
|
|
|
//===================================================================
|
|
|
|
class ThumbnailViewer::NameField : public TTextField {
|
|
Thumbnail *m_thumbnail;
|
|
|
|
public:
|
|
NameField(TWidget *parent) : TTextField(parent), m_thumbnail(0) {}
|
|
void onFocusChange(bool on) {
|
|
if (!on) close();
|
|
}
|
|
|
|
void close() {
|
|
if (m_thumbnail) {
|
|
try {
|
|
m_thumbnail->setName(toString(getText()));
|
|
} catch (...) {
|
|
TMessage::error("unable to change name");
|
|
}
|
|
}
|
|
hide();
|
|
}
|
|
|
|
void keyDown(int key, unsigned long flags, const TPoint &p) {
|
|
if (key == TK_Return)
|
|
close();
|
|
else
|
|
TTextField::keyDown(key, flags, p);
|
|
}
|
|
|
|
void setThumbnail(Thumbnail *thumbnail) {
|
|
m_thumbnail = thumbnail;
|
|
setText(m_thumbnail->getName());
|
|
selectAll();
|
|
}
|
|
};
|
|
|
|
//===================================================================
|
|
|
|
ThumbnailViewer::ThumbnailViewer(TWidget *parent, string name)
|
|
: TScrollView(parent, name)
|
|
, m_selectedItemIndex(-1)
|
|
, m_itemSize(94, 100)
|
|
, m_itemSpace(10, 10)
|
|
, m_margins(10, 10)
|
|
, m_playButtonBox(TPoint(85, 2), TDimension(10, 10))
|
|
, m_iconBox(TPoint(2 + 4 - 3, 20 + 4), TDimension(96 - 8, 78 - 8))
|
|
, m_textBox(TPoint(2 + 4 + 2 + 10, 2 + 2), TDimension(65, 18))
|
|
, m_flag(false)
|
|
, m_playing(false)
|
|
, m_loading(false)
|
|
, m_timerActive(false)
|
|
, m_dragDropArmed(false)
|
|
, m_oldPos(0, 0) {
|
|
setBackgroundColor(White);
|
|
m_nameField = new NameField(this);
|
|
m_nameField->hide();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
ThumbnailViewer::~ThumbnailViewer() { clearPointerContainer(m_items); }
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
int ThumbnailViewer::getColumnCount() const {
|
|
int columnWidth = m_itemSize.lx + m_itemSpace.lx;
|
|
int availableWidth = getLx() - m_margins.lx * 2 + m_itemSpace.lx;
|
|
return tmax(1, (availableWidth) / columnWidth);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
TPoint ThumbnailViewer::getItemPos(int index) {
|
|
int columnCount = getColumnCount();
|
|
int row = index / columnCount;
|
|
int col = index % columnCount;
|
|
int x = m_margins.lx + col * (m_itemSize.lx + m_itemSpace.lx);
|
|
int y = getLy() - m_margins.ly - m_itemSize.ly -
|
|
row * (m_itemSize.ly + m_itemSpace.ly);
|
|
return TPoint(x, y);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
TRect ThumbnailViewer::getItemBounds(int index) {
|
|
return TRect(getItemPos(index), m_itemSize);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
int ThumbnailViewer::findItem(const TPoint &pos) {
|
|
int columnCount = getColumnCount();
|
|
int col = (pos.x - m_margins.lx) / (m_itemSize.lx + m_itemSpace.lx);
|
|
int row = (getLy() - m_margins.ly - m_itemSpace.ly - pos.y) /
|
|
(m_itemSize.ly + m_itemSpace.ly);
|
|
int index = row * columnCount + col;
|
|
if (0 <= index && index < (int)m_items.size() &&
|
|
getItemBounds(index).contains(pos))
|
|
return index;
|
|
else
|
|
return -1;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
int ThumbnailViewer::getItemCount() const { return m_items.size(); }
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
Thumbnail *ThumbnailViewer::getItem(int index) const {
|
|
assert(0 <= index && index < (int)m_items.size());
|
|
return m_items[index];
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::configureNotify(const TDimension &d) {
|
|
TScrollView::configureNotify(d);
|
|
// m_nameField->setGeometry(TPoint(10,10), TDimension(100,30));
|
|
updateContentSize();
|
|
invalidate();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::drawFrame(int index) {
|
|
TPoint base = getItemPos(index);
|
|
assert(0 <= index && index < (int)m_items.size());
|
|
assert(m_items[index]->getRaster());
|
|
assert(m_iconBox.getSize() == m_items[index]->getRaster()->getSize());
|
|
rectwrite(m_items[index]->getRaster(), base + m_iconBox.getP00());
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::drawItem(int index) {
|
|
TPoint base = getItemPos(index);
|
|
if (index < 0 || index >= (int)m_items.size()) {
|
|
setColor(getBackgroundColor());
|
|
fillRect(TRect(base, m_itemSize));
|
|
return;
|
|
}
|
|
|
|
// setColor(Black);
|
|
// fillRect(TRect(base, m_itemSize));
|
|
|
|
Thumbnail *item = m_items[index];
|
|
bool selected = item != 0 && index == m_selectedItemIndex;
|
|
|
|
TRect r0(base, m_itemSize);
|
|
TRect r1 = m_iconBox + base;
|
|
TRect r2 = m_textBox + base;
|
|
|
|
setColor(selected ? Cyan : getBackgroundColor());
|
|
fillRect(r0.x0, r1.y0, r1.x0 - 1, r1.y1); // sinistra
|
|
fillRect(r1.x1 + 1, r1.y0, r0.x1, r1.y1); // destra
|
|
fillRect(r0.x0, r0.y0, r0.x1, r1.y0 - 1); // sotto
|
|
// fillRect(r1.x0,r1.y1+1,r1.x1,r0.y1); // sopra
|
|
TRect topLine(r0.x0, r1.y1 + 1, r0.x1, r0.y1);
|
|
TRect sceneLine = topLine;
|
|
sceneLine.y0 = sceneLine.y1 - 3;
|
|
topLine.y1 = sceneLine.y0 - 1;
|
|
fillRect(topLine);
|
|
|
|
if (item->getType() == Thumbnail::SCENE) {
|
|
setColor(Black);
|
|
drawRect(sceneLine);
|
|
setColor(White);
|
|
fillRect(sceneLine.enlarge(-1));
|
|
int x;
|
|
setColor(Black);
|
|
for (x = sceneLine.x0 + 5; x + 5 < sceneLine.x1; x += 10) {
|
|
int y = sceneLine.y0 + 1;
|
|
drawLine(x, y, x + 4, y);
|
|
y++;
|
|
x++;
|
|
drawLine(x, y, x + 4, y);
|
|
}
|
|
} else {
|
|
setColor(White);
|
|
fillRect(sceneLine);
|
|
}
|
|
|
|
string name = item->getName();
|
|
int maxWidth = r2.getLx() - 4;
|
|
TDimension ts = getTextSize(name);
|
|
if (ts.lx > maxWidth) {
|
|
do {
|
|
name.pop_back();
|
|
ts = getTextSize(name);
|
|
} while (name.size() > 1 && ts.lx > maxWidth);
|
|
}
|
|
|
|
TPoint textOrigin = r2.getP00() + TPoint(2 - 10, (r2.getLy() - ts.ly) / 2);
|
|
|
|
setColor(Black);
|
|
string fname = name;
|
|
string type = item->getPath().getType();
|
|
if (type != "") fname = fname + "." + type;
|
|
|
|
fname = item->getPath().getLevelName();
|
|
drawText(textOrigin, fname);
|
|
|
|
if (selected) {
|
|
TRect r = m_playButtonBox + base;
|
|
setColor(Blue);
|
|
if (m_playing) {
|
|
int x0 = r.x0, x3 = r.x1;
|
|
int x1 = (x0 + x3) / 2 - 1;
|
|
int x2 = x3 - (x1 - x0);
|
|
drawRect(x0, r.y0, x1, r.y1);
|
|
drawRect(x2, r.y0, x3, r.y1);
|
|
} else {
|
|
vector<TPoint> pts;
|
|
int d = (r.y1 - r.y0 + 1) / 2;
|
|
int x = r.x0;
|
|
int y = r.y0;
|
|
pts.push_back(TPoint(x, y));
|
|
pts.push_back(TPoint(x + d, y + d));
|
|
pts.push_back(TPoint(x, y + d * 2));
|
|
fillPolygon(Cyan, Blue, &pts[0], 3);
|
|
}
|
|
}
|
|
assert(0 <= index && index < (int)m_items.size());
|
|
assert(m_items[index]->getRaster());
|
|
assert(m_iconBox.getSize() == m_items[index]->getRaster()->getSize());
|
|
rectwrite(m_items[index]->getRaster(), base + m_iconBox.getP00());
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::drawBackground() {
|
|
int itemCount = m_items.size();
|
|
int columnCount = getColumnCount();
|
|
int rowCount = (itemCount + columnCount - 1) / columnCount;
|
|
|
|
TRect clipRect;
|
|
getClipRect(clipRect); // coordinate window
|
|
clipRect -= TPoint(m_xoff, m_yoff);
|
|
TRect rect;
|
|
rect.x0 = m_margins.lx;
|
|
rect.x1 = m_margins.lx + (m_itemSize.lx + m_itemSpace.lx) * columnCount -
|
|
m_itemSpace.lx - 1;
|
|
rect.y1 = getLy() - m_margins.ly - 1;
|
|
rect.y0 = rect.y1 - (m_itemSize.ly + m_itemSpace.ly) * rowCount +
|
|
m_itemSpace.ly + 1;
|
|
|
|
setColor(getBackgroundColor());
|
|
|
|
// alto
|
|
if (rect.y1 + 1 <= clipRect.y1)
|
|
fillRect(clipRect.x0, rect.y1 + 1, clipRect.x1, clipRect.y1);
|
|
|
|
// basso
|
|
if (clipRect.y0 <= rect.y0 - 1)
|
|
fillRect(clipRect.x0, clipRect.y0, clipRect.x1, rect.y0 - 1);
|
|
|
|
int y0 = tmax(clipRect.y0, rect.y0);
|
|
int y1 = tmin(clipRect.y1, rect.y1);
|
|
if (y0 <= y1) {
|
|
// sinistra
|
|
if (clipRect.x0 <= rect.x0 - 1) fillRect(clipRect.x0, y0, rect.x0 - 1, y1);
|
|
|
|
// destra
|
|
if (rect.x1 + 1 <= clipRect.x1) fillRect(rect.x1 + 1, y0, clipRect.x1, y1);
|
|
}
|
|
|
|
// interlinee verticali
|
|
for (int r = 0; r < rowCount; r++) {
|
|
int y1 = rect.y1 - (m_itemSize.ly + m_itemSpace.ly) * r + m_itemSpace.ly;
|
|
int y0 = y1 - m_itemSpace.ly + 1;
|
|
fillRect(clipRect.x0, y0, clipRect.x1, y1);
|
|
}
|
|
for (int c = 0; c < columnCount - 1; c++) {
|
|
int x0 =
|
|
m_margins.lx + (m_itemSize.lx + m_itemSpace.lx) * c + m_itemSize.lx;
|
|
int x1 = x0 + m_itemSpace.lx - 1;
|
|
fillRect(x0, clipRect.y0, x1, clipRect.y1);
|
|
}
|
|
|
|
// ultima riga
|
|
c = itemCount % columnCount;
|
|
if (c != 0) {
|
|
TRect box = getItemBounds(itemCount - 1);
|
|
if (box.y0 <= clipRect.y1 && box.y1 >= clipRect.y0 &&
|
|
box.x1 + 1 <= clipRect.x1)
|
|
fillRect(box.x1 + 1, box.y0, clipRect.x1, box.y1);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::repaint() {
|
|
if (m_flag) {
|
|
if (m_selectedItemIndex) drawFrame(m_selectedItemIndex);
|
|
} else {
|
|
// m_loadingDirectory = false;
|
|
// setColor(Black);
|
|
// fillRect(getBounds());
|
|
|
|
drawBackground();
|
|
|
|
TRect clipRect;
|
|
getClipRect(clipRect); // coordinate window
|
|
clipRect -= TPoint(m_xoff, m_yoff);
|
|
|
|
bool loading = false;
|
|
for (int i = 0; i < (int)m_items.size(); i++) {
|
|
TRect bounds = getItemBounds(i);
|
|
if (bounds.overlaps(clipRect)) {
|
|
drawItem(i);
|
|
if (m_items[i]->isIconLoaded() == false) loading = true;
|
|
}
|
|
}
|
|
if (loading) {
|
|
m_loading = true;
|
|
if (!m_timerActive) {
|
|
m_timerActive = true;
|
|
startTimer(200);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::select(int index) {
|
|
assert(index == -1 || 0 <= index && index < (int)m_items.size());
|
|
m_playing = false;
|
|
if (m_timerActive) {
|
|
m_timerActive = false;
|
|
stopTimer();
|
|
}
|
|
Thumbnail *thumbnail;
|
|
if (m_selectedItemIndex >= 0) {
|
|
thumbnail = m_items[m_selectedItemIndex];
|
|
thumbnail->setPlaying(false);
|
|
}
|
|
m_selectedItemIndex = index;
|
|
onSelect(m_selectedItemIndex);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::startPlaying() {
|
|
if (m_playing) return;
|
|
if (m_selectedItemIndex < 0) return;
|
|
m_playing = true;
|
|
assert(0 <= m_selectedItemIndex && m_selectedItemIndex < (int)m_items.size());
|
|
m_items[m_selectedItemIndex]->setPlaying(true);
|
|
if (!m_timerActive) {
|
|
m_timerActive = true;
|
|
startTimer(200);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::stopPlaying() {
|
|
if (!m_playing) return;
|
|
m_playing = false;
|
|
if (m_selectedItemIndex >= 0) {
|
|
assert(0 <= m_selectedItemIndex &&
|
|
m_selectedItemIndex < (int)m_items.size());
|
|
m_items[m_selectedItemIndex]->gotoFrame(0);
|
|
m_items[m_selectedItemIndex]->setPlaying(false);
|
|
}
|
|
if (m_timerActive) {
|
|
m_timerActive = false;
|
|
stopTimer();
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::leftButtonDown(const TMouseEvent &e) {
|
|
TPoint pos = e.m_pos - TPoint(m_xoff, m_yoff);
|
|
m_oldPos = e.m_pos;
|
|
m_dragDropArmed = false;
|
|
|
|
m_nameField->hide();
|
|
// if(setGeometry(m_textBox + bounds.getP00());
|
|
// m_nameField->setText(m_items[index]->getName());
|
|
// m_nameField->show();
|
|
|
|
int index = findItem(pos);
|
|
if (index >= 0) {
|
|
if (m_selectedItemIndex == index) {
|
|
TRect bounds = getItemBounds(index);
|
|
pos -= bounds.getP00();
|
|
if (m_playButtonBox.contains(pos)) {
|
|
if (!m_playing)
|
|
startPlaying();
|
|
else
|
|
stopPlaying();
|
|
invalidate();
|
|
} else if (m_textBox.contains(pos)) {
|
|
stopPlaying();
|
|
m_nameField->setGeometry(m_textBox + bounds.getP00() + TPoint(-10, 0));
|
|
m_nameField->setThumbnail(m_items[index]);
|
|
m_nameField->show();
|
|
setFocusOwner(m_nameField);
|
|
} else {
|
|
m_dragDropArmed = true;
|
|
}
|
|
} else {
|
|
select(index);
|
|
m_dragDropArmed = true;
|
|
}
|
|
} else
|
|
select(-1);
|
|
invalidate();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::leftButtonDrag(const TMouseEvent &e) {
|
|
if (!m_dragDropArmed || m_selectedItemIndex < 0) return;
|
|
if (norm2(e.m_pos - m_oldPos) < 100) return;
|
|
m_dragDropArmed = false;
|
|
|
|
Thumbnail *item = m_items[m_selectedItemIndex];
|
|
TFilePath path = item->getPath();
|
|
if (path.getWideString() != toWideString("")) {
|
|
TDropSource dropSource;
|
|
std::vector<std::string> v;
|
|
v.push_back(toString(path.getWideString()));
|
|
TDataObject data(v);
|
|
dropSource.doDragDrop(data);
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::leftButtonUp(const TMouseEvent &e) {
|
|
m_dragDropArmed = false;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::leftButtonDoubleClick(const TMouseEvent &e) {
|
|
TPoint pos = e.m_pos - TPoint(m_xoff, m_yoff);
|
|
m_nameField->hide();
|
|
int index = findItem(pos);
|
|
if (index >= 0) onDoubleClick(index);
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::onTimer(int) {
|
|
stopTimer();
|
|
m_timerActive = false;
|
|
if (m_playing && m_selectedItemIndex >= 0) {
|
|
Thumbnail *thumbnail = m_items[m_selectedItemIndex];
|
|
bool ret = thumbnail->nextFrame();
|
|
if (ret) {
|
|
m_timerActive = true;
|
|
startTimer(100);
|
|
} else {
|
|
thumbnail->gotoFrame(0);
|
|
thumbnail->setPlaying(false);
|
|
m_playing = false;
|
|
}
|
|
invalidate();
|
|
} else if (m_loading) {
|
|
for (int i = 0; i < (int)m_items.size(); i++)
|
|
if (!m_items[i]->isIconLoaded()) {
|
|
m_items[i]->loadIcon();
|
|
invalidate();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::addItem(Thumbnail *item) { m_items.push_back(item); }
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::removeItem(Thumbnail *item) {
|
|
std::vector<Thumbnail *>::iterator it =
|
|
std::find(m_items.begin(), m_items.end(), item);
|
|
if (it != m_items.end()) m_items.erase(it);
|
|
|
|
m_selectedItemIndex = -1;
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::clearItems() {
|
|
clearPointerContainer(m_items);
|
|
m_selectedItemIndex = -1;
|
|
m_playing = false;
|
|
m_loading = false;
|
|
if (m_timerActive) {
|
|
stopTimer();
|
|
m_timerActive = false;
|
|
}
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::loadDirectory(const TFilePath &dirPath,
|
|
const vector<string> &fileTypes) {
|
|
clearItems();
|
|
TFilePathSet fps;
|
|
|
|
try {
|
|
fps = TSystem::readDirectory(dirPath);
|
|
} catch (...) {
|
|
TMessage::error(toString(dirPath.getWideString()) +
|
|
": can't read directory");
|
|
updateContentSize();
|
|
return;
|
|
}
|
|
|
|
fps = TSystem::packLevelNames(fps);
|
|
fps.sort();
|
|
|
|
for (TFilePathSet::iterator it = fps.begin(); it != fps.end(); it++) {
|
|
try {
|
|
TFilePath fp = *it;
|
|
if (fp.getType() == "bmp" && fp.getName().find("_icon") != string::npos)
|
|
continue;
|
|
if (std::find(fileTypes.begin(), fileTypes.end(), fp.getType()) ==
|
|
fileTypes.end())
|
|
continue;
|
|
Thumbnail *item = FileThumbnail::create(m_iconBox.getSize(), fp);
|
|
if (item) m_items.push_back(item);
|
|
} catch (...) {
|
|
TMessage::error(toString(it->getWideString()) + ": can't read thumbnail");
|
|
}
|
|
}
|
|
updateContentSize();
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::updateContentSize() {
|
|
int itemCount = m_items.size();
|
|
int columnCount = getColumnCount();
|
|
int rowCount = (itemCount + columnCount - 1) / columnCount;
|
|
|
|
TRect rect;
|
|
int yrange = rowCount * (m_itemSize.ly + m_itemSpace.ly) - m_itemSpace.ly +
|
|
m_margins.ly * 2;
|
|
setContentSize(TDimension(getLx(), yrange));
|
|
}
|
|
|
|
//-------------------------------------------------------------------
|
|
|
|
void ThumbnailViewer::scrollPage(int y) { doScrollTo_y(tmax(y, 0)); }
|