426 lines
12 KiB
C++
426 lines
12 KiB
C++
#pragma once
|
|
|
|
#ifndef TW_INCLUDED
|
|
#define TW_INCLUDED
|
|
|
|
#include "traster.h"
|
|
|
|
#undef DVAPI
|
|
#undef DVVAR
|
|
#ifdef TWIN_EXPORTS
|
|
#define DVAPI DV_EXPORT_API
|
|
#define DVVAR DV_EXPORT_VAR
|
|
#else
|
|
#define DVAPI DV_IMPORT_API
|
|
#define DVVAR DV_IMPORT_VAR
|
|
#endif
|
|
|
|
class TMouseEvent;
|
|
class TCursor;
|
|
class TDragDropListener;
|
|
|
|
//-------------------------------------------------------------
|
|
|
|
class DVAPI TGuiColor {
|
|
int m_red, m_green, m_blue;
|
|
// mutable void* m_imp;
|
|
// bool m_isStock;
|
|
// int m_shade;
|
|
|
|
// TUINT32 *m_index;
|
|
// mutable bool m_allocated;
|
|
public:
|
|
// static const int m_maxShade;
|
|
|
|
TGuiColor(int r, int g, int b);
|
|
TGuiColor();
|
|
~TGuiColor();
|
|
|
|
// TGuiColor(const TGuiColor&);
|
|
// TGuiColor& operator=(const TGuiColor&);
|
|
|
|
// TUINT32 getIndex(int shade=0) const;
|
|
// TUINT32 getRGB(int shade=0) const;
|
|
|
|
int red() const { return m_red; }
|
|
int green() const { return m_green; }
|
|
int blue() const { return m_blue; }
|
|
|
|
void computeShade(int index, int &r, int &g, int &b) const;
|
|
|
|
// void* imp() const {return m_imp;}
|
|
// void imp(void* imp) const { m_imp = imp; }
|
|
// bool isStock() const { return m_isStock; }
|
|
|
|
protected:
|
|
void initStockColor();
|
|
};
|
|
|
|
//-------------------------------------------------------------
|
|
|
|
class TWidgetImp;
|
|
|
|
// class TTarget {};
|
|
// class TTimerTarget {};
|
|
|
|
class TWidget;
|
|
typedef std::vector<TWidget *> TWidgetList;
|
|
|
|
//-------------------------------------------------------------
|
|
|
|
class DVAPI TWidget
|
|
// : public TTarget, public TTimerTarget
|
|
{
|
|
public:
|
|
enum Alignment { BEGIN, CENTER, END };
|
|
enum FocusHandling { IGNORE_FOCUS, STOP_FOCUS, LISTEN_TO_FOCUS };
|
|
|
|
protected:
|
|
TRect m_placement;
|
|
int m_xoff, m_yoff;
|
|
|
|
bool m_mapped; // e' arrivato il MapNotify
|
|
bool m_hidden; // il widget non vuole mostrarsi
|
|
bool m_childrenChanged;
|
|
|
|
// TTimer *m_timer;
|
|
|
|
TWidget *m_parent, *m_sonKeeper;
|
|
std::string m_name, m_contextHelpReference;
|
|
std::wstring m_shortHelp, m_longHelp;
|
|
|
|
int m_cursorIdx;
|
|
|
|
TWidgetList *m_sons;
|
|
TWidgetImp *m_imp;
|
|
|
|
friend class TWidgetImp;
|
|
|
|
TGuiColor m_backgroundColor, m_foregroundColor;
|
|
bool m_popupMode, m_menuMode, m_fixedSize, m_fullColor, m_openGL;
|
|
bool m_enabled, m_menuRelated;
|
|
|
|
TDragDropListener *m_dragDropListener;
|
|
|
|
std::string m_fontName;
|
|
int m_fontSize;
|
|
int m_fontOrientation;
|
|
|
|
static TWidget *m_selectionOwner;
|
|
static TWidget *m_focusOwner;
|
|
|
|
// not implemented (cannot copy and assign widget)
|
|
private:
|
|
TWidget(const TWidget &);
|
|
TWidget &operator=(const TWidget &);
|
|
|
|
protected:
|
|
virtual void create();
|
|
virtual void setDecoration();
|
|
virtual void destroyImp();
|
|
void createSons();
|
|
|
|
public:
|
|
TWidget(TWidget *parent = 0, std::string name = "unnamed");
|
|
virtual ~TWidget();
|
|
|
|
//
|
|
// geometry
|
|
//
|
|
const TRect &getGeometry() const { return m_placement; }
|
|
TPoint getPosition() const { return m_placement.getP00(); }
|
|
virtual TPoint getHotSpot() const { return TPoint(0, 0); }
|
|
TDimension getSize() const { return m_placement.getSize(); }
|
|
TRect getBounds() const { return TRect(TPoint(), getSize()); }
|
|
int getLx() const { return m_placement.getLx(); }
|
|
int getLy() const { return m_placement.getLy(); }
|
|
|
|
inline void setPlacement(const TRect &rect) { m_placement = rect; }
|
|
|
|
inline void setGeometry(int x0, int y0, int x1, int y1) {
|
|
setGeometry(TRect(x0, y0, x1, y1));
|
|
}
|
|
|
|
virtual void setGeometry(const TRect &rect);
|
|
void setGeometry(const TPoint &pos, const TDimension &size) {
|
|
setGeometry(TRect(pos, size));
|
|
}
|
|
inline void setSize(int w, int h) {
|
|
setGeometry(getPosition(), TDimension(w, h));
|
|
}
|
|
|
|
inline void setSize(const TDimension &size) { setSize(size.lx, size.ly); }
|
|
inline void setPosition(int x, int y) {
|
|
setGeometry(TPoint(x, y), getSize());
|
|
}
|
|
inline void setPosition(const TPoint &pt) { setGeometry(pt, getSize()); }
|
|
inline bool contains(int x, int y) const { return contains(TPoint(x, y)); }
|
|
inline bool contains(const TPoint &p) const {
|
|
return m_placement.contains(p);
|
|
}
|
|
|
|
TPoint getScreenPosition() const;
|
|
|
|
//
|
|
// name, parent & sons
|
|
//
|
|
inline TWidget *getParent() const { return m_parent; }
|
|
inline std::string getName() const { return m_name; }
|
|
virtual void setParent(TWidget *p);
|
|
virtual void addSon(TWidget *son);
|
|
virtual void removeSon(TWidget *son);
|
|
inline int getSonCount() const { return m_sons->size(); }
|
|
inline TWidget *getSon(int i) const {
|
|
return i < 0 || i >= (int)(m_sons->size()) ? 0 : (*m_sons)[i];
|
|
}
|
|
|
|
//
|
|
// help messages
|
|
//
|
|
std::wstring getLongHelp() const;
|
|
std::wstring getShortHelp() const;
|
|
|
|
void setHelp(std::string shortHelp, std::string longHelp);
|
|
void setHelp(std::wstring shortHelp, std::wstring longHelp);
|
|
|
|
virtual std::string getContextHelpReference(const TPoint &) {
|
|
return m_contextHelpReference;
|
|
}
|
|
|
|
void setContextHelpReference(std::string s) { m_contextHelpReference = s; }
|
|
|
|
// void delegateHelpToParent();
|
|
|
|
virtual std::wstring getTooltipString(const TPoint &) {
|
|
return getShortHelp();
|
|
}
|
|
|
|
//
|
|
// misc
|
|
//
|
|
inline bool isHidden() const { return m_hidden; }
|
|
inline bool isMapped() const { return m_mapped; }
|
|
|
|
void enable();
|
|
void disable();
|
|
inline bool isEnabled() const { return m_enabled; }
|
|
|
|
void show();
|
|
void hide();
|
|
|
|
// n.b. non chiamare map/unmap, ma show/hide
|
|
virtual void map();
|
|
virtual void unmap();
|
|
|
|
virtual void doModal();
|
|
|
|
virtual void undock();
|
|
virtual void dock(TWidget *parent);
|
|
virtual TWidget *findSubWidget(const TPoint &pt);
|
|
|
|
virtual void repaint();
|
|
|
|
void sendRepaint() { sendRepaint(getBounds()); }
|
|
void sendRepaint(const TRect &);
|
|
|
|
virtual void paste();
|
|
|
|
virtual void startDragAndDrop(std::string stringToDrop);
|
|
|
|
typedef unsigned int CursorIndex;
|
|
|
|
inline CursorIndex getCurrentCursor() { return m_cursorIdx; }
|
|
void changeCursor(CursorIndex new_cur);
|
|
|
|
TWidgetImp *getImp() { return m_imp; }
|
|
|
|
void startTimer(TINT32 period);
|
|
void stopTimer();
|
|
|
|
virtual void getSelection();
|
|
|
|
virtual void onFocusChange(bool on);
|
|
|
|
virtual bool getFocus() { return false; }
|
|
virtual void circulateFocus();
|
|
|
|
virtual void copyRegion(const TPoint &dst, const TPoint &src,
|
|
const TDimension &size);
|
|
|
|
//
|
|
// draw
|
|
//
|
|
void flush();
|
|
|
|
virtual void draw() {}
|
|
virtual void invalidate();
|
|
virtual void invalidate(const TRect &rect);
|
|
|
|
void getClipRect(TRect &rect);
|
|
|
|
virtual void clear();
|
|
|
|
virtual void drawText(const TPoint &p, std::string text);
|
|
virtual void drawText(const TPoint &p, std::wstring text);
|
|
|
|
virtual void drawText(const TRect &r, std::string text,
|
|
Alignment alignment = CENTER);
|
|
virtual void drawText(const TRect &r, std::wstring text,
|
|
Alignment alignment = CENTER);
|
|
virtual void drawMultiLineText(const TRect &r, std::string text);
|
|
virtual void drawMultiLineText(const TRect &r, std::wstring text);
|
|
|
|
virtual TDimension getTextSize(std::string text);
|
|
virtual TDimension getTextSize(std::wstring text);
|
|
|
|
virtual TDimension getTextSize(std::string text, std::string font,
|
|
int fontSize);
|
|
virtual TDimension getTextSize(std::wstring text, std::string font,
|
|
int fontSize);
|
|
|
|
inline void drawPoint(int x, int y) { drawLine(x, y, x, y); }
|
|
|
|
virtual void drawLine(const TPoint &p0, const TPoint &p1);
|
|
inline void drawLine(int x0, int y0, int x1, int y1) {
|
|
drawLine(TPoint(x0, y0), TPoint(x1, y1));
|
|
}
|
|
virtual void drawVLine(const TPoint &p0, int length) {
|
|
drawLine(p0, p0 + TPoint(0, length - 1));
|
|
}
|
|
virtual void drawHLine(const TPoint &p0, int length) {
|
|
drawLine(p0, p0 + TPoint(length - 1, 0));
|
|
}
|
|
|
|
virtual void drawDottedLine(const TPoint &p0, const TPoint &p1);
|
|
inline void drawDottedLine(int x0, int y0, int x1, int y1) {
|
|
drawDottedLine(TPoint(x0, y0), TPoint(x1, y1));
|
|
}
|
|
|
|
virtual void drawRect(const TRect &);
|
|
virtual void fillRect(const TRect &);
|
|
|
|
virtual void drawRect(int x0, int y0, int x1, int y1) {
|
|
drawRect(TRect(x0, y0, x1, y1));
|
|
}
|
|
virtual void fillRect(int x0, int y0, int x1, int y1) {
|
|
fillRect(TRect(x0, y0, x1, y1));
|
|
}
|
|
|
|
virtual void draw3DRect(const TRect &, bool pressed = false, int border = 1);
|
|
virtual void fill3DRect(const TRect &, bool pressed = false, int border = 1);
|
|
|
|
virtual void drawDottedRect(const TRect &);
|
|
virtual void drawDottedRect(int x0, int y0, int x1, int y1) {
|
|
drawDottedRect(TRect(x0, y0, x1, y1));
|
|
}
|
|
|
|
virtual void fillPolygon(const TGuiColor &fillColor,
|
|
const TGuiColor &borderColor, const TPoint points[],
|
|
int pointCount);
|
|
|
|
virtual void clear(const TRect &);
|
|
|
|
virtual void drawImage(int index, const TPoint &);
|
|
|
|
virtual void setColor(const TGuiColor &, int shade = 0);
|
|
virtual void setBackgroundColor(const TGuiColor &);
|
|
|
|
TGuiColor getBackgroundColor() const { return m_backgroundColor; }
|
|
TGuiColor getForegroundColor() const { return m_foregroundColor; }
|
|
|
|
static const TGuiColor White;
|
|
static const TGuiColor Black;
|
|
|
|
virtual void rectwrite(const TRaster32P &, const TPoint &);
|
|
|
|
virtual void setFontSize(int size);
|
|
virtual void setFont(std::string name, int size = 0, int orientation = 0);
|
|
|
|
//
|
|
// events
|
|
//
|
|
|
|
virtual void enter(const TPoint &) {}
|
|
virtual void leave(const TPoint &) {}
|
|
|
|
virtual void mouseMove(const TMouseEvent &) {}
|
|
virtual void leftButtonDown(const TMouseEvent &) {}
|
|
virtual void leftButtonDrag(const TMouseEvent &) {}
|
|
virtual void leftButtonUp(const TMouseEvent &) {}
|
|
virtual void rightButtonDown(const TMouseEvent &) {}
|
|
virtual void rightButtonDrag(const TMouseEvent &) {}
|
|
virtual void rightButtonUp(const TMouseEvent &) {}
|
|
virtual void middleButtonDown(const TMouseEvent &) {}
|
|
virtual void middleButtonDrag(const TMouseEvent &) {}
|
|
virtual void middleButtonUp(const TMouseEvent &) {}
|
|
virtual void leftButtonDoubleClick(const TMouseEvent &) {}
|
|
virtual void middleButtonDoubleClick(const TMouseEvent &) {}
|
|
virtual void rightButtonDoubleClick(const TMouseEvent &) {}
|
|
|
|
virtual void mouseWheel(const TMouseEvent &, int wheel) {}
|
|
|
|
virtual void keyDown(int, TUINT32, const TPoint &) {}
|
|
|
|
virtual void configureNotify(const TDimension &) {}
|
|
|
|
virtual void onPaste(std::string) {}
|
|
|
|
// virtual void close() {unmap();}
|
|
|
|
virtual void onDrop(std::string) {}
|
|
|
|
virtual std::string getToolTip() { return ""; }
|
|
|
|
virtual void onTimer(int) {}
|
|
|
|
virtual void onChildrenChanged() {}
|
|
|
|
virtual bool onNcPaint(bool is_active, const TDimension &window_size,
|
|
const TRect &caption_rect);
|
|
|
|
public:
|
|
static void setFocusOwner(TWidget *w);
|
|
static TWidget *getFocusOwner();
|
|
|
|
virtual FocusHandling getFocusHandling() const { return IGNORE_FOCUS; }
|
|
|
|
static void placeInteractively(TRect &);
|
|
|
|
// brutto brutto qui
|
|
virtual void maximize(TWidget *) {}
|
|
virtual bool isMaximized(TWidget *) { return false; }
|
|
|
|
//
|
|
// drag & drop
|
|
//
|
|
// virtual bool acceptDrop() {return false;}
|
|
void enableDropTarget(TDragDropListener *dragDropListener);
|
|
TDragDropListener *getDragDropListener() const { return m_dragDropListener; }
|
|
|
|
static void yield(); // processa tutti gli eventi in attesa
|
|
static void setMode(int mode);
|
|
|
|
// misc
|
|
TPoint getAbsolutePosition() const;
|
|
static TPoint getMouseAbsolutePosition();
|
|
TPoint getMouseRelativePosition() const;
|
|
|
|
// brutto. serve per filtrare gli eventi durante il menu event loop
|
|
bool isMenuRelated() const { return m_menuRelated; }
|
|
|
|
// se non altro e' brutto il nome
|
|
// NB: il nome e' brutto... ora questo e' anche sbagliato
|
|
static void processAllPendingMessages(); // questa processa solo i WM_PAINT
|
|
|
|
static void processAllPendingMessages2(); // questa processa tutto
|
|
|
|
// mah? serve a evitare il circuito invalidate() -> repaint(); chiama
|
|
// direttamente
|
|
// repaint() (creando l'opportuno GC su windows)
|
|
// void paintRegion(const TRect &rect);
|
|
|
|
static TDimension getScreenSize();
|
|
static void getScreenPlacement(std::vector<TRectI> &);
|
|
};
|
|
|
|
#endif
|