1026 lines
22 KiB
C++
Executable File
1026 lines
22 KiB
C++
Executable File
extern "C"
|
|
{
|
|
#include <xvt.h>
|
|
#include <xvtcm.h>
|
|
#include <cpb.h>
|
|
}
|
|
|
|
#if XVT_OS != XVT_OS_WIN
|
|
#error "This file should be compiled for Windows only"
|
|
#endif
|
|
|
|
#include <colors.h>
|
|
#include <controls.h>
|
|
#include <urldefid.h>
|
|
#include <utility.h>
|
|
#include <xvtility.h>
|
|
|
|
#include <windows.h>
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TPicture_array
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TPicture_array
|
|
{
|
|
enum { MAXPIC = 128 };
|
|
PICTURE _picture[MAXPIC];
|
|
HBITMAP _graybmp;
|
|
HBRUSH _graybrush;
|
|
|
|
public:
|
|
PICTURE getbmp(short id);
|
|
PICTURE operator[](short id) { return _picture[id-BMP_OK]; }
|
|
HBRUSH graybrush() const { return _graybrush; }
|
|
|
|
void reset();
|
|
|
|
TPicture_array();
|
|
~TPicture_array() { reset(); } // Shouldn't do anything
|
|
};
|
|
|
|
|
|
PICTURE TPicture_array::getbmp(short id)
|
|
{
|
|
const int i = id-BMP_OK;
|
|
CHECKD(i >= 0 && i < MAXPIC, "Control ID out of range", id);
|
|
|
|
if (_picture[i] != NULL)
|
|
{
|
|
if (i < 100) return _picture[i];
|
|
picture_free(_picture[i]);
|
|
}
|
|
_picture[i] = cpb_picture_load(id);
|
|
|
|
if (_picture[i] == NULL)
|
|
error_box("Can't load picture %d", id);
|
|
|
|
return _picture[i];
|
|
}
|
|
|
|
|
|
TPicture_array::TPicture_array()
|
|
{
|
|
memset(_picture, 0, sizeof(_picture));
|
|
|
|
const byte even = 1+4+16+64;
|
|
const byte odd = 2+8+32+128;
|
|
const byte grid[8] = { odd, even, odd, even, odd, even, odd, even };
|
|
_graybmp = CreateBitmap(8, 8, 1, 1, grid);
|
|
_graybrush = CreatePatternBrush(_graybmp);
|
|
}
|
|
|
|
void TPicture_array::reset()
|
|
{
|
|
for (int i = 0; i < MAXPIC; i++)
|
|
if (_picture[i] != NULL)
|
|
{
|
|
picture_free(_picture[i]);
|
|
_picture[i] = NULL;
|
|
}
|
|
|
|
if (_graybrush)
|
|
{
|
|
DeleteObject(_graybrush);
|
|
DeleteObject(_graybmp);
|
|
_graybrush = _graybmp = 0;
|
|
}
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Static data and functions
|
|
///////////////////////////////////////////////////////////
|
|
|
|
HIDDEN TControl* creating = NULL;
|
|
HIDDEN long ctl_flags;
|
|
HIDDEN WINDOW _hdc;
|
|
HIDDEN RCT _client;
|
|
HIDDEN TPicture_array cpb;
|
|
|
|
HIDDEN void get_geometry(WINDOW win)
|
|
{
|
|
get_client_rect(win, &_client);
|
|
_client.right--; _client.bottom--;
|
|
_hdc = win;
|
|
}
|
|
|
|
HIDDEN void set_creation_args(WIN_CREATION_ARGS *a)
|
|
{
|
|
long& flags = a->win_flags;
|
|
if (ctl_flags & CTL_FLAG_DISABLED) flags |= WSF_DISABLED;
|
|
if (ctl_flags & CTL_FLAG_INVISIBLE) flags |= WSF_INVISIBLE;
|
|
|
|
switch(creating->id())
|
|
{
|
|
case -2:
|
|
flags |= WSF_DISABLED;
|
|
break;
|
|
default:break;
|
|
}
|
|
}
|
|
|
|
void xvt_draw_rect(WINDOW win, const RCT&rect, COLOR lt, COLOR rb, short depth)
|
|
{
|
|
RCT r = rect;
|
|
|
|
CPEN pen;
|
|
pen.width = 1;
|
|
pen.pat = PAT_SOLID;
|
|
pen.style = P_SOLID;
|
|
pen.color = lt;
|
|
|
|
for (short d = 0; d < depth;)
|
|
{
|
|
win_set_cpen(win, &pen);
|
|
|
|
PNT p; // Current vertex of the rectangle
|
|
|
|
bool drawed = FALSE;
|
|
if (lt != COLOR_LTGRAY)
|
|
{
|
|
p.h = r.left; p.v = r.bottom;
|
|
win_move_to(win, p);
|
|
|
|
p.v = r.top;
|
|
win_draw_line(win, p);
|
|
p.h = r.right;
|
|
win_draw_line(win, p);
|
|
drawed = TRUE;
|
|
}
|
|
|
|
if (rb != COLOR_LTGRAY)
|
|
{
|
|
if (pen.color != rb)
|
|
{
|
|
pen.color = rb;
|
|
win_set_cpen(win, &pen);
|
|
}
|
|
if (!drawed)
|
|
{
|
|
p.h = r.right; p.v = r.top;
|
|
win_move_to(win, p);
|
|
}
|
|
p.v = r.bottom;
|
|
win_draw_line(win, p);
|
|
p.h = r.left;
|
|
win_draw_line(win, p);
|
|
}
|
|
|
|
if (++d < depth)
|
|
{
|
|
r.left++; r.top++;
|
|
r.right--; r.bottom--;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void TControl::create(
|
|
short left, short top, short right, short bottom, const char* title,
|
|
WINDOW parent, long flags, long app_data, short id)
|
|
{
|
|
bool bold = *title == '@';
|
|
if (bold) title += 2;
|
|
|
|
const int prop_count = 1;
|
|
const char* prop_list[prop_count+1] =
|
|
{
|
|
title,
|
|
NULL
|
|
};
|
|
|
|
_id = id;
|
|
_caption = title;
|
|
_disabled = (flags & CTL_FLAG_DISABLED) != 0;
|
|
_checked = (flags & CTL_FLAG_CHECKED) != 0;
|
|
_multiple = (flags & CTL_FLAG_MULTIPLE) != 0;
|
|
_focused = FALSE;
|
|
|
|
creating = this;
|
|
ctl_flags = flags;
|
|
_win = xvtcm_create(id, left, top, right, bottom,
|
|
prop_count, (char**)prop_list, parent,
|
|
0, 0, NULL, handler, set_creation_args);
|
|
CHECKS(_win, "Can't create control ", title);
|
|
|
|
creating = NULL;
|
|
set_app_data(_win, app_data);
|
|
xvt_set_font(_win, FF_FIXED, bold ? FS_BOLD : 0);
|
|
}
|
|
|
|
|
|
// Virtual destructor needed to make derived descrutors active!
|
|
TControl::~TControl()
|
|
{}
|
|
|
|
|
|
long TControl::handler(WINDOW win, EVENT* ep)
|
|
{
|
|
static bool tracking = FALSE;
|
|
static bool pressed = FALSE;
|
|
|
|
if (ep->type == E_CREATE)
|
|
xvtcm_eh_start(win, ep);
|
|
|
|
TControl** model = (TControl**)xvtcm_get_model(win, sizeof(TControl*));
|
|
CHECK(model, "Can't get the model");
|
|
|
|
TControl*& cc = *model;
|
|
if (ep->type == E_CREATE)
|
|
{
|
|
CHECK(creating, "Can't create a NULL control");
|
|
cc = creating;
|
|
}
|
|
CHECK(cc, "Can't handle a NULL control");
|
|
|
|
if (creating == NULL) switch(ep->type)
|
|
{
|
|
case E_FOCUS:
|
|
cc->focus((bool)ep->v.active);
|
|
case E_UPDATE:
|
|
cc->update();
|
|
break;
|
|
case E_MOUSE_DOWN:
|
|
trap_mouse(win);
|
|
tracking = pressed = TRUE;
|
|
cc->mouse_down(ep->v.mouse.where);
|
|
break;
|
|
case E_CHAR:
|
|
{
|
|
KEY key = e_char_to_key(ep);
|
|
switch(key)
|
|
{
|
|
case K_SPACE:
|
|
cc->mouse_up();
|
|
break;
|
|
default:
|
|
{
|
|
WINDOW parent = get_parent(win);
|
|
dispatch_event(parent, ep);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
break;
|
|
case E_MOUSE_MOVE:
|
|
if (tracking)
|
|
{
|
|
RCT r;
|
|
get_client_rect(win, &r);
|
|
if (pt_in_rect(&r, ep->v.mouse.where))
|
|
{
|
|
if (!pressed)
|
|
{
|
|
cc->mouse_down(ep->v.mouse.where);
|
|
pressed = TRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (pressed)
|
|
{
|
|
cc->update();
|
|
pressed = FALSE;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
case E_MOUSE_UP:
|
|
if (tracking)
|
|
{
|
|
release_mouse();
|
|
tracking = FALSE;
|
|
if (pressed)
|
|
{
|
|
cc->mouse_up();
|
|
pressed = FALSE;
|
|
}
|
|
}
|
|
break;
|
|
case E_DESTROY:
|
|
delete *model;
|
|
*model = NULL;
|
|
xvtcm_eh_end(win, ep);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return 0L;
|
|
}
|
|
|
|
void TControl::enable(bool on)
|
|
{
|
|
if (on == disabled())
|
|
{
|
|
_disabled = !on;
|
|
update();
|
|
enable_window(win(), on);
|
|
}
|
|
}
|
|
|
|
void TControl::check(bool on)
|
|
{
|
|
_checked = on;
|
|
}
|
|
|
|
void TControl::update() const
|
|
{
|
|
if (_win != _hdc)
|
|
get_geometry(_win);
|
|
clear_window(_hdc, MASK_BACK_COLOR);
|
|
win_set_fore_color(_hdc, disabled() ? COLOR_GRAY : COLOR_BLACK);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TText
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TText : public TControl
|
|
{
|
|
protected:
|
|
virtual WIN_TYPE type() const { return WC_TEXT; }
|
|
virtual void update() const;
|
|
|
|
public:
|
|
TText(short left, short top, short right, short bottom,
|
|
const char* caption, WINDOW parent,
|
|
long flags, long app_data, short id);
|
|
};
|
|
|
|
TText::TText(short left, short top, short right, short bottom,
|
|
const char* caption, WINDOW parent,
|
|
long flags, long app_data, short id)
|
|
{
|
|
create(left, top, right, bottom, caption, parent, flags, app_data, id);
|
|
}
|
|
|
|
void TText::update() const
|
|
{
|
|
TControl::update();
|
|
win_draw_text(_hdc, _client.left, _client.top+CHARY-3, (char*)caption(), -1);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TGroup
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TGroup : public TText
|
|
{
|
|
protected:
|
|
virtual WIN_TYPE type() const { return WC_GROUPBOX; }
|
|
virtual void update() const;
|
|
void draw_round_rect(const RCT& r, COLOR c) const;
|
|
|
|
public:
|
|
TGroup(short left, short top, short right, short bottom,
|
|
const char* caption, WINDOW parent,
|
|
long flags, long app_data, short id);
|
|
};
|
|
|
|
TGroup::TGroup(short left, short top, short right, short bottom,
|
|
const char* caption, WINDOW parent,
|
|
long flags, long app_data, short id)
|
|
: TText(left, top, right, bottom, caption, parent, flags, app_data,
|
|
(id < 0) ? -2 : id)
|
|
{}
|
|
|
|
void TGroup::draw_round_rect(const RCT& r, COLOR c) const
|
|
{
|
|
CPEN pen;
|
|
pen.width = 2;
|
|
pen.pat = PAT_SOLID;
|
|
pen.style = P_SOLID;
|
|
pen.color = c;
|
|
win_set_cpen(_hdc, &pen);
|
|
|
|
CBRUSH brush = { PAT_HOLLOW, MASK_BACK_COLOR };
|
|
win_set_cbrush(_hdc, &brush);
|
|
win_draw_roundrect(_hdc, (RCT*)&r, ROWY, ROWY);
|
|
}
|
|
|
|
void TGroup::update() const
|
|
{
|
|
TText::update();
|
|
RCT r = _client;
|
|
r.top += CHARY;
|
|
r.right-=4; r.bottom-=ROWY/2;
|
|
if (multiple())
|
|
{
|
|
r.left++; r.top++; r.right--; r.bottom--;
|
|
draw_round_rect(r, COLOR_BLUE);
|
|
}
|
|
else
|
|
{
|
|
xvt_draw_rect(_hdc, r, COLOR_GRAY, COLOR_CYAN);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Button
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TButton : public TControl
|
|
{
|
|
protected:
|
|
enum { DEPTH = 2 };
|
|
|
|
virtual WIN_TYPE type() const { return WC_PUSHBUTTON; }
|
|
virtual void update() const;
|
|
virtual void mouse_down(PNT where);
|
|
virtual void mouse_up();
|
|
virtual void check(bool on);
|
|
virtual void draw_pressed(bool pressed) const;
|
|
|
|
public:
|
|
TButton(short left, short top, short right, short bottom,
|
|
const char* caption,WINDOW parent,
|
|
long flags, long app_data, short id);
|
|
};
|
|
|
|
|
|
TButton::TButton(short left, short top, short right, short bottom,
|
|
const char* caption, WINDOW parent,
|
|
long flags, long app_data, short id)
|
|
{
|
|
create(left, top, right, bottom, caption, parent, flags, app_data, id);
|
|
}
|
|
|
|
|
|
void TButton::draw_pressed(bool pressed) const
|
|
{
|
|
get_geometry(win());
|
|
|
|
clear_window(_hdc, COLOR_LTGRAY);
|
|
RCT r = _client;
|
|
xvt_draw_rect(_hdc, r, COLOR_BLACK, COLOR_BLACK);
|
|
|
|
COLOR lt = pressed ? COLOR_GRAY : COLOR_WHITE;
|
|
COLOR rb = pressed ? COLOR_LTGRAY : COLOR_GRAY;
|
|
|
|
for (int i = DEPTH; i--;)
|
|
{
|
|
r.left++; r.top++; r.right--; r.bottom--;
|
|
xvt_draw_rect(_hdc, r, lt, rb);
|
|
if (i == 1) lt = COLOR_LTGRAY;
|
|
}
|
|
}
|
|
|
|
|
|
void TButton::update() const
|
|
{
|
|
TControl::update();
|
|
draw_pressed(checked());
|
|
}
|
|
|
|
void TButton::mouse_down(PNT)
|
|
{
|
|
draw_pressed(!checked());
|
|
}
|
|
|
|
void TButton::mouse_up()
|
|
{
|
|
draw_pressed(checked());
|
|
|
|
EVENT e; // Notification message
|
|
e.type = E_CONTROL;
|
|
e.v.ctl.id = id();
|
|
e.v.ctl.ci.type = type();
|
|
e.v.ctl.ci.win = win();
|
|
dispatch_event(get_parent(win()), &e);
|
|
}
|
|
|
|
void TButton::check(bool on)
|
|
{
|
|
TControl::check(on);
|
|
draw_pressed(on);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TPush button
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TPush_button : public TButton
|
|
{
|
|
PICTURE _picup, _picdn;
|
|
byte _dx, _dy;
|
|
|
|
protected:
|
|
void draw_pressed(bool pressed) const;
|
|
void update() const;
|
|
|
|
public:
|
|
TPush_button(short left, short top, short right, short bottom,
|
|
const char* caption, WINDOW parent,
|
|
long flags, long app_data, short id);
|
|
virtual ~TPush_button();
|
|
};
|
|
|
|
TPush_button::TPush_button(short left, short top, short right, short bottom,
|
|
const char* caption, WINDOW parent,
|
|
long flags, long app_data, short id)
|
|
: TButton(left-(id == DLG_F9), top, right, bottom,
|
|
caption, parent, flags, app_data, id),
|
|
_picup(0L), _picdn(0L)
|
|
{
|
|
const int height = bottom-top;
|
|
|
|
switch(id)
|
|
{
|
|
case DLG_OK:
|
|
if (height > ROWY && strcmp("Conferma", caption) == 0)
|
|
caption = format("#%d", BMP_OK);
|
|
break;
|
|
case DLG_CANCEL:
|
|
if (height > ROWY && strcmp("Annulla", caption) == 0)
|
|
caption = format("#%d", BMP_CANCEL);
|
|
break;
|
|
case DLG_QUIT:
|
|
caption = format("#%d#%d", BMP_QUIT, BMP_QUITDN);
|
|
break;
|
|
case DLG_SELECT:
|
|
caption = format("#%d", BMP_SELECT);
|
|
break;
|
|
case DLG_DELREC:
|
|
caption = format("#%d#%d", BMP_DELREC, BMP_DELRECDN);
|
|
break;
|
|
case DLG_NEWREC:
|
|
if (height > ROWY && strcmp("~Nuovo", caption) == 0) // Puo' essere Gestione
|
|
caption = format("#%d#%d", BMP_NEWREC, BMP_NEWRECDN);
|
|
break;
|
|
case DLG_FIRSTREC:
|
|
caption = format("#%d", BMP_FIRSTREC);
|
|
break;
|
|
case DLG_PREVREC:
|
|
caption = format("#%d", BMP_PREVREC);
|
|
break;
|
|
case DLG_STOPREC:
|
|
caption = format("#%d", BMP_STOPREC);
|
|
break;
|
|
case DLG_NEXTREC:
|
|
caption = format("#%d", BMP_NEXTREC);
|
|
break;
|
|
case DLG_LASTREC:
|
|
caption = format("#%d", BMP_LASTREC);
|
|
break;
|
|
case DLG_SAVEREC:
|
|
caption = format("#%d#%d", BMP_SAVEREC, BMP_SAVERECDN);
|
|
break;
|
|
case DLG_FINDREC:
|
|
caption = format("#%d", BMP_FINDREC);
|
|
break;
|
|
case DLG_F9:
|
|
caption = format("#%d", BMP_SEARCH);
|
|
break;
|
|
case DLG_LINK:
|
|
caption = format("#%d", BMP_LINK);
|
|
break;
|
|
case DLG_EDIT:
|
|
caption = format("#%d", BMP_EDIT);
|
|
break;
|
|
case DLG_PRINT:
|
|
caption = format("#%d", BMP_PRINT);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (*caption == '#')
|
|
{
|
|
int pid = atoi(caption+1);
|
|
_picup = cpb.getbmp(pid);
|
|
const char* d = strrchr(caption, '#');
|
|
if (d > caption)
|
|
{
|
|
pid = atoi(d+1);
|
|
_picdn = cpb.getbmp(pid);
|
|
}
|
|
|
|
RCT r;
|
|
cpb_get_picture_size(_picup, &r);
|
|
_dx = byte((right-left-r.right+1) >> 1);
|
|
_dy = byte((height-r.bottom) >> 1);
|
|
}
|
|
else
|
|
{
|
|
_dx = (right-left-strlen(caption)*CHARX) >> 1;
|
|
_dy = ((height-CHARY) >> 1) + CHARY-3;
|
|
}
|
|
}
|
|
|
|
TPush_button::~TPush_button()
|
|
{
|
|
}
|
|
|
|
void TPush_button::draw_pressed(bool pressed) const
|
|
{
|
|
TButton::draw_pressed(pressed);
|
|
|
|
const int p = pressed ? DEPTH : 0;
|
|
if (_picup)
|
|
{
|
|
const PICTURE pic = (pressed && _picdn) ? _picdn : _picup;
|
|
cpb_win_picture_draw_at(_hdc, pic, _dx+p, _dy+p);
|
|
}
|
|
else
|
|
{
|
|
const char* t = caption();
|
|
|
|
win_set_fore_color(_hdc, COLOR_WHITE);
|
|
win_draw_text(_hdc, _dx+p+1, _dy+p+1, (char*)t, -1);
|
|
|
|
const COLOR c = disabled() ? DISABLED_COLOR : NORMAL_COLOR;
|
|
win_set_fore_color(_hdc, c);
|
|
win_draw_text(_hdc, _dx+p, _dy+p, (char*)t, -1);
|
|
}
|
|
}
|
|
|
|
void TPush_button::update() const
|
|
{
|
|
draw_pressed(FALSE);
|
|
if (focused() && id() != DLG_F9)
|
|
{
|
|
HWND hwnd = (HWND)get_value(_hdc, ATTR_NATIVE_WINDOW);
|
|
HDC hdc = GetDC(hwnd);
|
|
RECT r;
|
|
r.left = _client.left+DEPTH+1;
|
|
r.top = _client.top+DEPTH;
|
|
r.right = _client.right-DEPTH-1;
|
|
r.bottom = _client.bottom-DEPTH;
|
|
DrawFocusRect(hdc, &r);
|
|
ReleaseDC(hwnd, hdc);
|
|
} else
|
|
if (disabled() && _picup)
|
|
{
|
|
CPEN pen;
|
|
pen.width = 1;
|
|
pen.pat = PAT_SOLID;
|
|
pen.style = P_SOLID;
|
|
pen.color = COLOR_LTGRAY;
|
|
win_set_cpen(_hdc, &pen);
|
|
|
|
const int sx = _client.left+DEPTH+1;
|
|
const int sy = _client.top+DEPTH+1;
|
|
const int ex = _client.right-DEPTH-1;
|
|
const int ey = _client.bottom-DEPTH-1;
|
|
|
|
for (int i = sx; i < ex; i += 2)
|
|
{
|
|
PNT p = { sy, i };
|
|
win_move_to(_hdc, p);
|
|
p.v = ey;
|
|
win_draw_line(_hdc, p);
|
|
}
|
|
for (i = sy; i < ey; i += 2)
|
|
{
|
|
PNT p = { i, sx };
|
|
win_move_to(_hdc, p);
|
|
p.h = ex;
|
|
win_draw_line(_hdc, p);
|
|
}
|
|
/*
|
|
HWND hwnd = (HWND)get_value(_hdc, ATTR_NATIVE_WINDOW);
|
|
HDC hdc = GetDC(hwnd);
|
|
RECT r;
|
|
r.left = _client.left+DEPTH+1;
|
|
r.top = _client.top+DEPTH+1;
|
|
r.right = _client.right-DEPTH-1;
|
|
r.bottom = _client.bottom-DEPTH-1;
|
|
HBRUSH oldBrush = SelectObject(hdc, cpb.graybrush());
|
|
PatBlt(hdc, r.left, r.top, r.right-r.left, r.bottom-r.top, 0xFA0089); // Real magic number
|
|
SelectObject(hdc, oldBrush);
|
|
ReleaseDC(hwnd, hdc);
|
|
*/
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TPage_button
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TPage_button : public TControl
|
|
{
|
|
enum { height = 19, width = 32 };
|
|
byte _flag;
|
|
|
|
protected:
|
|
virtual void update() const;
|
|
virtual void mouse_down(PNT where);
|
|
virtual void mouse_up();
|
|
|
|
public:
|
|
TPage_button(WINDOW parent, byte flag);
|
|
};
|
|
|
|
TPage_button::TPage_button(WINDOW parent, byte flag) : _flag(flag)
|
|
{
|
|
RCT r; get_client_rect(parent, &r);
|
|
create(r.right-width, r.bottom-height, r.right, r.bottom,
|
|
"", parent, 0L, 0L, DLG_PAGE);
|
|
cpb.getbmp(BMP_BOOK1 + flag -1);
|
|
}
|
|
|
|
void TPage_button::mouse_down(PNT where)
|
|
{
|
|
check(where.h < (width>>1));
|
|
}
|
|
|
|
void TPage_button::mouse_up()
|
|
{
|
|
dispatch_e_char(get_parent(win()), checked() ? K_PREV : K_NEXT);
|
|
}
|
|
|
|
void TPage_button::update() const
|
|
{
|
|
TControl::update();
|
|
cpb_win_picture_draw_at(_hdc, cpb[BMP_BOOK1 + _flag -1], 0, 0);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TTag_button
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TTag_button : public TControl
|
|
{
|
|
enum { height = 12, width = 32 };
|
|
byte _curr;
|
|
byte _page;
|
|
byte _pages;
|
|
|
|
WINDOW _parent;
|
|
|
|
protected:
|
|
virtual void update() const;
|
|
virtual void mouse_down(PNT where);
|
|
virtual void mouse_up();
|
|
|
|
public:
|
|
TTag_button(WINDOW parent, byte p, byte tot);
|
|
};
|
|
|
|
TTag_button::TTag_button(WINDOW parent, byte p, byte tot)
|
|
: _parent(parent), _page(p), _pages(tot), _curr(p)
|
|
{
|
|
RCT r; get_client_rect(parent, &r);
|
|
create(0, 0, r.right, CHARY, "", parent,0L,0L, DLG_PAGETAGS);
|
|
}
|
|
|
|
void TTag_button::update() const
|
|
{
|
|
get_geometry(win());
|
|
clear_window(_hdc, COLOR_GRAY);
|
|
|
|
for (int i = 0; i < _pages; i++)
|
|
{
|
|
RCT r; set_rect(&r, width*i, 0, width*(i+1), _client.bottom+4);
|
|
CBRUSH b = { PAT_SOLID, (i == _page) ? MASK_BACK_COLOR : COLOR_GRAY };
|
|
win_set_cbrush(_hdc, &b);
|
|
win_set_std_cpen(_hdc, TL_PEN_BLACK);
|
|
win_draw_rect(_hdc, &r);
|
|
|
|
if (i == _page)
|
|
xvt_draw_rect(_hdc, r, COLOR_CYAN, COLOR_GRAY);
|
|
|
|
char n[4]; sprintf(n, "%d", i+1);
|
|
win_draw_text(_hdc, (width-CHARX)/2 + i*width, CHARY-3, n, -1);
|
|
}
|
|
|
|
CPEN pen;
|
|
pen.width = 1;
|
|
pen.pat = PAT_SOLID;
|
|
pen.style = P_SOLID;
|
|
pen.color = COLOR_CYAN;
|
|
win_set_cpen(_hdc, &pen);
|
|
|
|
PNT p = { _client.bottom, 0 };
|
|
win_move_to(_hdc, p);
|
|
p.h = width*_page;
|
|
win_draw_line(_hdc, p);
|
|
p.h += width+1;
|
|
win_move_to(_hdc, p);
|
|
p.h = _client.right;
|
|
win_draw_line(_hdc, p);
|
|
}
|
|
|
|
void TTag_button::mouse_down(PNT where)
|
|
{
|
|
_curr = where.h / width;
|
|
if (_curr >= _pages) _curr = _pages-1;
|
|
}
|
|
|
|
void TTag_button::mouse_up()
|
|
{
|
|
if (_curr != _page)
|
|
dispatch_e_char(_parent, K_CTRL + K_F1 + _curr);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Checkbox
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TCheckbox : public TButton
|
|
{
|
|
static bool _bmploaded;
|
|
|
|
protected:
|
|
virtual WIN_TYPE type() const;
|
|
virtual void draw_pressed(bool pressed) const;
|
|
virtual void update() const;
|
|
|
|
int radio() const { return multiple() ? 1 : 0; }
|
|
|
|
public:
|
|
TCheckbox(short left, short top, short right, short bottom,
|
|
const char* caption, WINDOW parent,
|
|
long flags, long app_data, short id);
|
|
virtual ~TCheckbox();
|
|
};
|
|
|
|
bool TCheckbox::_bmploaded = FALSE;
|
|
|
|
TCheckbox::TCheckbox(
|
|
short left, short top, short right, short bottom,
|
|
const char* caption, WINDOW parent,
|
|
long flags, long app_data, short id)
|
|
: TButton(left, top, right, bottom,
|
|
caption, parent, flags, app_data, id)
|
|
{
|
|
if (!_bmploaded)
|
|
{
|
|
cpb.getbmp(BMP_CHECK_ON);
|
|
cpb.getbmp(BMP_CHECK_OFF);
|
|
cpb.getbmp(BMP_RADIO_ON);
|
|
cpb.getbmp(BMP_RADIO_OFF);
|
|
_bmploaded = TRUE;
|
|
}
|
|
}
|
|
|
|
|
|
TCheckbox::~TCheckbox()
|
|
{
|
|
}
|
|
|
|
|
|
WIN_TYPE TCheckbox::type() const
|
|
{
|
|
return multiple() ? WC_RADIOBUTTON : WC_CHECKBOX;
|
|
}
|
|
|
|
|
|
void TCheckbox::draw_pressed(bool pressed) const
|
|
{
|
|
get_geometry(win());
|
|
PICTURE pic;
|
|
if (radio())
|
|
pic = pressed ? cpb[BMP_RADIO_ON] : cpb[BMP_RADIO_OFF];
|
|
else
|
|
pic = pressed ? cpb[BMP_CHECK_ON] : cpb[BMP_CHECK_OFF];
|
|
cpb_win_picture_draw_at(_hdc, pic, _client.left, _client.top);
|
|
}
|
|
|
|
|
|
void TCheckbox::update() const
|
|
{
|
|
TButton::update();
|
|
|
|
const int x = _client.left+20;
|
|
const int y = _client.top + CHARY-1;
|
|
|
|
if (focused())
|
|
{
|
|
#if XVT_OS == XVT_OS_WIN
|
|
RECT r;
|
|
r.left = x-2; r.top = _client.top;
|
|
r.right = _client.right; r.bottom = _client.bottom;
|
|
|
|
HWND hwnd = (HWND)get_value(_hdc, ATTR_NATIVE_WINDOW);
|
|
HDC hdc = GetDC(hwnd);
|
|
DrawFocusRect(hdc, &r);
|
|
ReleaseDC(hwnd, hdc);
|
|
#endif
|
|
}
|
|
|
|
win_draw_text(_hdc, x, y, (char*)caption(), -1);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// User functions
|
|
///////////////////////////////////////////////////////////
|
|
|
|
WINDOW xvt_create_checkbox(
|
|
short left, short top, short right, short bottom,
|
|
const char* caption,
|
|
WINDOW parent,
|
|
long flags,
|
|
long app_data,
|
|
int id)
|
|
{
|
|
TCheckbox* cb = new TCheckbox(left, top, right, bottom,
|
|
caption, parent,
|
|
flags, app_data, id);
|
|
|
|
// It'll destroy itself automagically :-)
|
|
|
|
return cb->win();
|
|
}
|
|
|
|
WINDOW xvt_create_radiobutton(
|
|
short left, short top, short right, short bottom,
|
|
const char* caption,
|
|
WINDOW parent,
|
|
long flags,
|
|
long app_data,
|
|
int id)
|
|
{
|
|
flags |= CTL_FLAG_MULTIPLE;
|
|
TCheckbox* cb = new TCheckbox(left, top, right, bottom,
|
|
caption, parent,
|
|
flags, app_data, id);
|
|
|
|
// It'll destroy itself automagically :-)
|
|
return cb->win();
|
|
}
|
|
|
|
|
|
WINDOW xvt_create_pushbutton(
|
|
short left, short top, short right, short bottom,
|
|
const char* caption,
|
|
WINDOW parent,
|
|
long flags,
|
|
long app_data,
|
|
int id)
|
|
{
|
|
TControl* pb;
|
|
|
|
switch (id)
|
|
{
|
|
case DLG_PAGE:
|
|
pb = new TPage_button(parent, (byte)flags);
|
|
break;
|
|
case DLG_PAGETAGS:
|
|
pb = new TTag_button(parent, (byte)flags, (byte)app_data);
|
|
break;
|
|
default:
|
|
if (bottom-top > ROWY)
|
|
{
|
|
top += 6;
|
|
bottom -= ROWY/2 -4;
|
|
}
|
|
pb = new TPush_button(left, top, right, bottom,
|
|
caption, parent,
|
|
flags, app_data, id);
|
|
}
|
|
|
|
// It'll destroy itself automagically :-)
|
|
return pb->win();
|
|
}
|
|
|
|
|
|
WINDOW xvt_create_text(
|
|
short left, short top, short right, short bottom,
|
|
const char* caption,
|
|
WINDOW parent,
|
|
long flags,
|
|
long app_data,
|
|
int id)
|
|
{
|
|
TText* cb = new TText(left, top, right, bottom,
|
|
caption, parent,
|
|
flags, app_data, id);
|
|
// It'll destroy itself automagically :-)
|
|
return cb->win();
|
|
}
|
|
|
|
|
|
|
|
|
|
WINDOW xvt_create_groupbox(
|
|
short left, short top, short right, short bottom,
|
|
const char* caption,
|
|
WINDOW parent,
|
|
long flags,
|
|
long app_data,
|
|
int id)
|
|
{
|
|
TGroup* cb = new TGroup(left, top, right, bottom,
|
|
caption, parent,
|
|
flags, app_data, id);
|
|
// It'll destroy itself automagically :-)
|
|
return cb->win();
|
|
}
|
|
|
|
|
|
void free_controls_bmp()
|
|
{
|
|
cpb.reset();
|
|
}
|
|
|
|
|
|
TControl* TControl::WINDOW2TControl(WINDOW win)
|
|
{
|
|
TControl** model = (TControl**)xvtcm_get_model(win, 0);
|
|
CHECK(model && *model, "Can't get the model from a window");
|
|
return *model;
|
|
}
|