50fe8cea88
Files correlati : xvaga.dll Ricompilazione Demo : [ ] Commento : 0000875: griglie - patch 98 la prima nota, in questa versione emette delle righe di separazione campi della griglia non corrispondenti alle colonne, se si allarga la colonna la riga divisoria finta sparisce. git-svn-id: svn://10.65.10.50/trunk@17310 c028cbd2-c16b-5b4b-a496-9718f37d4682
1549 lines
39 KiB
C++
Executable File
1549 lines
39 KiB
C++
Executable File
#include "wxinc.h"
|
|
#include "xvt.h"
|
|
#include "xvtwin.h"
|
|
#include "statbar.h"
|
|
|
|
#include <wx/filename.h>
|
|
#include <wx/notebook.h>
|
|
#include <wx/treectrl.h>
|
|
#include <wx/vlbox.h>
|
|
#include <wx/aui/aui.h>
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Utility functions
|
|
///////////////////////////////////////////////////////////
|
|
|
|
static wxBitmap Image2Bitmap(XVT_IMAGE image, BOOLEAN trans)
|
|
{
|
|
if (image == NULL)
|
|
return wxNullBitmap;
|
|
|
|
wxImage& img = *(wxImage*)image;
|
|
if (trans && !img.HasMask())
|
|
{
|
|
const int r = img.GetRed(0,0);
|
|
const int g = img.GetGreen(0,0);
|
|
const int b = img.GetBlue(0,0);
|
|
img.SetMask();
|
|
img.SetMaskColour(r, g, b);
|
|
}
|
|
return wxBitmap(img);
|
|
}
|
|
|
|
static int RoundToIcon(int nSize)
|
|
{
|
|
nSize = ((nSize+3) / 8) * 8;
|
|
if (nSize < 16) nSize = 16;
|
|
if (nSize > 128) nSize = 128;
|
|
return nSize;
|
|
}
|
|
|
|
const wxBitmap& _GetToolResource(int nIcon, int nDesiredSize)
|
|
{
|
|
static wxHashTable _tool_icons;
|
|
|
|
if (nDesiredSize < 16) nDesiredSize = 16; else
|
|
if (nDesiredSize > 128) nDesiredSize = 128;
|
|
const long nCode = 1000*nIcon + nDesiredSize;
|
|
wxBitmap* bmp = (wxBitmap*)_tool_icons.Get(nCode);
|
|
if (bmp == NULL)
|
|
{
|
|
const int nIco[] = { nIcon, 100, ICON_RSRC, 0 };
|
|
for (int i = 0; nIco[i]; i++)
|
|
{
|
|
wxString strName = _GetResourceName("Tool", nIco[i]).Lower();
|
|
if (!strName.IsEmpty() && ::wxFileExists(strName))
|
|
{
|
|
if (strName.EndsWith(".ico"))
|
|
{
|
|
const wxIcon ico(strName, wxBITMAP_TYPE_ICO);
|
|
bmp = new wxBitmap(ico);
|
|
}
|
|
else
|
|
{
|
|
wxImage img(strName, wxBITMAP_TYPE_ANY);
|
|
img.Rescale(nDesiredSize, nDesiredSize, wxIMAGE_QUALITY_HIGH);
|
|
bmp = new wxBitmap(img);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
_tool_icons.Put(nCode, bmp);
|
|
}
|
|
return *bmp;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Controls functions
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TwxScrollBar : public wxScrollBar
|
|
{
|
|
protected:
|
|
virtual bool AcceptsFocus() const { return false; } // Altrimenti mette il flag wxTAB_TRAVERSAL
|
|
|
|
public:
|
|
TwxScrollBar(wxWindow *parent, wxWindowID id,
|
|
const wxPoint& pos, const wxSize& size, long style)
|
|
{ Create(parent, id, pos, size, style); }
|
|
};
|
|
|
|
class TwxNoteBook : public wxAuiNotebook
|
|
{
|
|
enum { BOOK_ICO_SIZE = 16 };
|
|
bool m_bSuspended;
|
|
|
|
DECLARE_EVENT_TABLE()
|
|
DECLARE_DYNAMIC_CLASS(TwxNoteBook)
|
|
|
|
protected:
|
|
void OnPageChanged(wxAuiNotebookEvent& e);
|
|
long Flags2Style(long flags) const;
|
|
|
|
TwxNoteBook() {}
|
|
|
|
public:
|
|
int ChangeSelection(size_t tab_no); // wxNotebook had it!
|
|
void SetTabImage(size_t tab_no, XVT_IMAGE img);
|
|
|
|
short AddTab(wxWindow* pPage, const wxString text, XVT_IMAGE img = NULL, short idx = -1);
|
|
TwxNoteBook(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style);
|
|
~TwxNoteBook();
|
|
};
|
|
|
|
class TwxTreeCtrl : public wxTreeCtrl
|
|
{
|
|
WX_DECLARE_VOIDPTR_HASH_MAP(int, XVT_IMAGE_Map);
|
|
XVT_IMAGE_Map m_img;
|
|
|
|
wxFont m_font;
|
|
int m_nFrozen;
|
|
|
|
private:
|
|
int img2int(XVT_IMAGE img); // Store img into internal image list
|
|
void OnClick(wxTreeEvent& evt, bool bDouble);
|
|
|
|
protected:
|
|
DECLARE_EVENT_TABLE();
|
|
void OnExpanding(wxTreeEvent& e); // Called when node in about to be expanded
|
|
void OnCollapsed(wxTreeEvent& e); // Called when node is collapsed
|
|
void OnSelected(wxTreeEvent& e); // Calls OnClick(e, false)
|
|
void OnActivated(wxTreeEvent& e); // Calls OnClick(e, true)
|
|
void OnRightDown(wxMouseEvent& e);
|
|
|
|
public:
|
|
void SetNodeImages(const wxTreeItemId& id, XVT_IMAGE item_image,
|
|
XVT_IMAGE collapsed_image, XVT_IMAGE expanded_image);
|
|
virtual bool SetFont(const wxFont& font) { m_font = font; return font.IsOk(); }
|
|
virtual wxFont GetFont() const;
|
|
|
|
void Suspend();
|
|
void Resume();
|
|
TwxTreeCtrl(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size);
|
|
};
|
|
|
|
struct TwxOutlookItem
|
|
{
|
|
wxString m_strText;
|
|
short m_nIconId;
|
|
int m_nFlags;
|
|
};
|
|
|
|
class TwxOutlookBar : public wxVListBox
|
|
{
|
|
enum { MAX_ITEMS = 32 };
|
|
TwxOutlookItem m_item[MAX_ITEMS];
|
|
bool m_bCaptured;
|
|
int m_nHovering;
|
|
|
|
DECLARE_EVENT_TABLE()
|
|
|
|
protected:
|
|
virtual void OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const;
|
|
virtual void OnDrawItem(wxDC& dc, const wxRect& rect, size_t n) const;
|
|
virtual wxCoord OnMeasureItem(size_t n) const;
|
|
virtual void OnMouseMove(wxMouseEvent& e);
|
|
virtual void OnMouseCaptureLost(wxMouseCaptureLostEvent& e);
|
|
virtual void OnSelected(wxCommandEvent& e);
|
|
|
|
public:
|
|
int Add(short nIconId, const wxString strText, int nFlags);
|
|
TwxOutlookBar(wxWindow *parent, wxWindowID id, const wxPoint& pos, const wxSize& size, long style);
|
|
~TwxOutlookBar();
|
|
};
|
|
|
|
WINDOW xvt_ctl_create_def(WIN_DEF *win_def_p, WINDOW parent_win, long app_data)
|
|
{
|
|
wxASSERT(win_def_p != NULL);
|
|
const wxRect rct = NormalizeRCT(&win_def_p->rct);
|
|
wxWindow* pParent = (wxWindow*)parent_win;
|
|
const wxWindowID id = win_def_p->v.ctl.ctrl_id;
|
|
|
|
WINDOW win = NULL_WIN;
|
|
switch (win_def_p->wtype)
|
|
{
|
|
case WC_HSCROLL: /* horizontal scrollbar control */
|
|
case WC_VSCROLL: /* vertical scrollbar control */
|
|
{
|
|
const long style = win_def_p->wtype == WC_HSCROLL ? wxSB_HORIZONTAL : wxSB_VERTICAL;
|
|
TwxScrollBar* sb = new TwxScrollBar(pParent, id, rct.GetPosition(), rct.GetSize(), style);
|
|
win = (WINDOW)sb;
|
|
}
|
|
break;
|
|
case WC_HGAUGE: /* horizontal progress bar control */
|
|
case WC_VGAUGE: /* vertical progress bar control */
|
|
{
|
|
const long style = (win_def_p->wtype == WC_HGAUGE) ? wxGA_HORIZONTAL : wxGA_VERTICAL;
|
|
wxGauge* pg = new wxGauge(pParent, id, app_data, rct.GetPosition(), rct.GetSize(), style);
|
|
win = (WINDOW)pg;
|
|
}
|
|
break;
|
|
case WC_HSLIDER: /* horizontal slider control */
|
|
case WC_VSLIDER: /* vertical slider control */
|
|
{
|
|
const long style = win_def_p->wtype == WC_HSLIDER ? wxSL_HORIZONTAL : wxSL_VERTICAL;
|
|
wxSlider* sc = new wxSlider(pParent, id, 0, 0, app_data, rct.GetPosition(), rct.GetSize(), style);
|
|
win = (WINDOW)sc;
|
|
}
|
|
break;
|
|
case WC_PUSHBUTTON: /* bottone normale */
|
|
{
|
|
wxButton* pb = NULL;
|
|
if (win_def_p->text && *win_def_p->text) // Bottone normale con label
|
|
{
|
|
pb = new wxButton(pParent, id, win_def_p->text, rct.GetPosition(), rct.GetSize());
|
|
}
|
|
else
|
|
{ // Bottone figo con immagini
|
|
wxBitmap bmp;
|
|
pb = new wxBitmapButton(pParent, id, bmp, rct.GetPosition(), rct.GetSize());
|
|
}
|
|
win = (WINDOW)pb;
|
|
}
|
|
break;
|
|
case WC_CHECKBOX: /* check box */
|
|
{
|
|
long style = wxCHK_2STATE | wxTRANSPARENT_WINDOW;
|
|
if (win_def_p->wtype == CTL_FLAG_RIGHT_JUST)
|
|
style |= wxALIGN_RIGHT;
|
|
wxCheckBox* cb = new wxCheckBox(pParent, id, win_def_p->text,
|
|
rct.GetPosition(), rct.GetSize(), style);
|
|
win = (WINDOW)cb;
|
|
}
|
|
break;
|
|
case WC_RADIOBUTTON: /* radio button */
|
|
{
|
|
wxRadioButton* rb = new wxRadioButton(pParent, id, win_def_p->text,
|
|
rct.GetPosition(), rct.GetSize(), wxRB_SINGLE);
|
|
win = (WINDOW)rb;
|
|
}
|
|
break;
|
|
case WC_NOTEBK:
|
|
{
|
|
TwxNoteBook* nb = new TwxNoteBook(pParent, id, rct.GetPosition(), rct.GetSize(), win_def_p->v.ctl.flags);
|
|
win = (WINDOW)nb;
|
|
}
|
|
break;
|
|
case WC_TREE:
|
|
{
|
|
TwxTreeCtrl* tv = new TwxTreeCtrl(pParent, id, rct.GetPosition(), rct.GetSize());
|
|
win = (WINDOW)tv;
|
|
XVT_FNTID font_id = win_def_p->v.ctl.font_id;
|
|
if (font_id == NULL)
|
|
font_id = xvt_dwin_get_font(parent_win);
|
|
if (font_id != NULL)
|
|
{
|
|
const wxFont& font = ((TFontId*)font_id)->Font(NULL, win);
|
|
tv->SetFont(font);
|
|
}
|
|
}
|
|
break;
|
|
case WC_OUTLOOKBAR:
|
|
{
|
|
long style = 0;
|
|
TwxOutlookBar* tob = new TwxOutlookBar(pParent, id, rct.GetPosition(), rct.GetSize(), style);
|
|
win = (WINDOW)tob;
|
|
XVT_FNTID font_id = win_def_p->v.ctl.font_id;
|
|
if (font_id == NULL)
|
|
font_id = xvt_dwin_get_font(parent_win);
|
|
if (font_id != NULL)
|
|
{
|
|
const wxFont& font = ((TFontId*)font_id)->Font(NULL, win);
|
|
tob->SetFont(font);
|
|
}
|
|
}
|
|
break;
|
|
default:
|
|
SORRY_BOX(); break;
|
|
}
|
|
|
|
if (win != NULL)
|
|
{
|
|
wxWindow& w = *(wxWindow*)win;
|
|
const long flags = win_def_p->v.ctl.flags;
|
|
if (flags & CTL_FLAG_INVISIBLE) w.Hide();
|
|
if (flags & CTL_FLAG_DISABLED) w.Disable();
|
|
}
|
|
|
|
return win;
|
|
}
|
|
|
|
void xvt_ctl_check_radio_button(WINDOW win, WINDOW* wins, int NbrWindows)
|
|
{
|
|
wxASSERT(NbrWindows >= 2);
|
|
for (int i = 0; i < NbrWindows; i++)
|
|
{
|
|
wxRadioButton* rb = wxDynamicCast((wxWindow*)wins[i], wxRadioButton);
|
|
if (rb != NULL)
|
|
rb->SetValue(win == wins[i]);
|
|
}
|
|
}
|
|
|
|
void xvt_ctl_set_checked(WINDOW win, BOOLEAN bCheck)
|
|
{
|
|
wxCheckBox* cb = (wxCheckBox*)win;
|
|
wxASSERT(cb != NULL);
|
|
cb->SetValue(bCheck != 0);
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Buttons
|
|
///////////////////////////////////////////////////////////
|
|
|
|
void xvt_btn_set_images(WINDOW win, XVT_IMAGE up, XVT_IMAGE down)
|
|
{
|
|
if (win != NULL_WIN && up != NULL)
|
|
{
|
|
wxBitmapButton* pb = wxDynamicCast((wxWindow*)win, wxBitmapButton);
|
|
if (pb != NULL)
|
|
{
|
|
wxBitmap bmpUp(Image2Bitmap(up, TRUE));
|
|
if (bmpUp.Ok())
|
|
{
|
|
pb->SetBitmapLabel(bmpUp);
|
|
const wxImage imgGay = ((wxImage*)up)->ConvertToGreyscale();
|
|
wxBitmap bmpGay(imgGay);
|
|
pb->SetBitmapDisabled(bmpGay);
|
|
}
|
|
if (down != NULL)
|
|
{
|
|
wxBitmap bmpDown(Image2Bitmap(down, TRUE));
|
|
if (bmpDown.Ok())
|
|
pb->SetBitmapSelected(bmpDown);
|
|
}
|
|
else
|
|
{
|
|
if (bmpUp.Ok())
|
|
pb->SetBitmapSelected(bmpUp);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Pane interface
|
|
///////////////////////////////////////////////////////////
|
|
|
|
static wxAuiManager* FindPaneManager(WINDOW win)
|
|
{
|
|
wxAuiManager* pManager = NULL;
|
|
if (win != NULL_WIN)
|
|
{
|
|
wxWindow* pwin = wxStaticCast((wxObject*)win, wxWindow);
|
|
pManager = wxAuiManager::GetManager(pwin);
|
|
}
|
|
return pManager;
|
|
}
|
|
|
|
static wxAuiPaneInfo* LockPane(WINDOW win)
|
|
{
|
|
wxAuiManager* pManager = FindPaneManager(win);
|
|
if (pManager != NULL)
|
|
{
|
|
wxAuiPaneInfo& pane = pManager->GetPane((wxWindow*)win);
|
|
if (pane.IsOk())
|
|
return &pane;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
static void UnlockPane(WINDOW win)
|
|
{
|
|
wxAuiManager* pManager = FindPaneManager(win);
|
|
if (pManager != NULL)
|
|
pManager->Update();
|
|
}
|
|
|
|
BOOLEAN xvt_pane_add(WINDOW win, WINDOW pane, const char* name, int dock, int flags)
|
|
{
|
|
BOOLEAN done = FALSE;
|
|
if (win != NULL_WIN && pane != NULL_WIN && name && *name)
|
|
{
|
|
TwxWindow* owner = wxStaticCast((wxObject*)win, TwxWindow);
|
|
wxWindow* child = wxStaticCast((wxObject*)pane, wxWindow);
|
|
done = owner->AddPane(child, name, dock, flags);
|
|
}
|
|
return done;
|
|
}
|
|
|
|
BOOLEAN xvt_pane_set_title(WINDOW win, const char* title)
|
|
{
|
|
wxAuiPaneInfo* pane = LockPane(win);
|
|
if (pane != NULL)
|
|
{
|
|
pane->Caption(title);
|
|
UnlockPane(win);
|
|
}
|
|
return pane != NULL;
|
|
}
|
|
|
|
XVTDLL BOOLEAN xvt_pane_change_flags(WINDOW win, int set, int rst)
|
|
{
|
|
wxAuiPaneInfo* pane = LockPane(win);
|
|
if (pane != NULL && (set || rst))
|
|
{
|
|
if (set) pane->SetFlag(set, true);
|
|
if (rst) pane->SetFlag(rst, false);
|
|
UnlockPane(win);
|
|
}
|
|
return pane != NULL;
|
|
}
|
|
|
|
XVTDLL BOOLEAN xvt_pane_detach(WINDOW win)
|
|
{
|
|
BOOLEAN ok = FALSE;
|
|
wxAuiManager* pManager = FindPaneManager(win);
|
|
if (pManager != NULL)
|
|
{
|
|
ok = pManager->DetachPane((wxWindow*)win);
|
|
pManager->Update();
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
XVTDLL BOOLEAN xvt_pane_manager_load_perspective(WINDOW win, const char* perspective)
|
|
{
|
|
BOOLEAN ok = FALSE;
|
|
if (perspective && *perspective)
|
|
{
|
|
wxAuiManager* pManager = FindPaneManager(win);
|
|
if (pManager != NULL)
|
|
{
|
|
const wxString str = perspective;
|
|
ok = pManager->LoadPerspective(str, true);
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
XVTDLL int xvt_pane_manager_save_perspective(WINDOW win, char* perspective, int max_size)
|
|
{
|
|
int nSize = 0;
|
|
wxAuiManager* pManager = FindPaneManager(win);
|
|
if (pManager != NULL)
|
|
{
|
|
const wxString str = pManager->SavePerspective();
|
|
nSize = str.Len()+1;
|
|
if (perspective != NULL && max_size > 0)
|
|
wxStrncpy(perspective, str, max_size);
|
|
}
|
|
return nSize;
|
|
}
|
|
|
|
|
|
XVTDLL BOOLEAN xvt_pane_set_size_range(WINDOW win, int min_size, int best_size, int max_size)
|
|
{
|
|
BOOLEAN ok = FALSE;
|
|
wxAuiPaneInfo* pane = LockPane(win);
|
|
if (pane != NULL)
|
|
{
|
|
if (min_size > 0 || max_size > 0)
|
|
{
|
|
if (best_size <= 0)
|
|
{
|
|
if (min_size > 0)
|
|
best_size = max_size > 0 ? (min_size+max_size) / 2 : min_size;
|
|
else
|
|
best_size = max_size;
|
|
}
|
|
wxSize szMin(-1, -1), szBst(-1, -1), szMax(-1, -1);
|
|
if (pane->IsTopDockable() || pane->IsBottomDockable())
|
|
{
|
|
szMin.y = min_size;
|
|
szBst.y = best_size;
|
|
szMax.y = max_size;
|
|
}
|
|
else
|
|
{
|
|
szMin.x = min_size;
|
|
szBst.x = best_size;
|
|
szMax.x = max_size;
|
|
}
|
|
pane->MinSize(szMin);
|
|
pane->BestSize(szBst);
|
|
pane->MaxSize(szMax);
|
|
}
|
|
pane->Resizable(min_size != max_size);
|
|
pane->DockFixed(min_size == max_size);
|
|
UnlockPane(win);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// Notebook interface
|
|
///////////////////////////////////////////////////////////
|
|
|
|
IMPLEMENT_DYNAMIC_CLASS(TwxNoteBook, wxAuiNotebook)
|
|
|
|
#define CAST_NOTEBOOK(win, nb) TwxNoteBook& nb = *wxStaticCast((wxObject*)win, TwxNoteBook);
|
|
|
|
inline bool VALID_NOTEBOOK(WINDOW notebk, short page_no)
|
|
{ return page_no >= 0 && wxDynamicCast((wxObject*)notebk, TwxNoteBook)!=NULL; }
|
|
|
|
BEGIN_EVENT_TABLE(TwxNoteBook, wxAuiNotebook)
|
|
EVT_AUINOTEBOOK_PAGE_CHANGED(wxID_ANY, OnPageChanged)
|
|
END_EVENT_TABLE();
|
|
|
|
void TwxNoteBook::OnPageChanged(wxAuiNotebookEvent& evt)
|
|
{
|
|
if (!m_bSuspended)
|
|
{
|
|
m_bSuspended = true;
|
|
EVENT e; memset(&e, 0, sizeof(EVENT));
|
|
e.type = E_CONTROL;
|
|
e.v.ctl.id = evt.GetId();
|
|
e.v.ctl.ci.type = WC_NOTEBK;
|
|
e.v.ctl.ci.win = WINDOW(this);
|
|
e.v.ctl.ci.v.notebk.face = (WINDOW)GetPage(evt.GetSelection());
|
|
e.v.ctl.ci.v.notebk.tab_no = evt.GetSelection();
|
|
e.v.ctl.ci.v.notebk.page_no = evt.GetOldSelection();
|
|
|
|
TwxWindow* win = wxStaticCast(GetParent(), TwxWindow);
|
|
win->DoXvtEvent(e);
|
|
m_bSuspended = false;
|
|
}
|
|
}
|
|
|
|
short TwxNoteBook::AddTab(wxWindow* pPage, const wxString text, XVT_IMAGE xvt_img, short idx)
|
|
{
|
|
wxBitmap bmp;
|
|
|
|
if (xvt_img != NULL)
|
|
{
|
|
wxImage& img = *wxStaticCast(xvt_img, wxImage);
|
|
img.Rescale(BOOK_ICO_SIZE, BOOK_ICO_SIZE, wxIMAGE_QUALITY_HIGH);
|
|
bmp = Image2Bitmap(xvt_img, true);
|
|
}
|
|
if (idx < 0 || idx >= (int)GetPageCount())
|
|
{
|
|
AddPage(pPage, text, false, bmp);
|
|
idx = GetPageCount()-1;
|
|
}
|
|
else
|
|
InsertPage(idx, pPage, text, false, bmp);
|
|
|
|
return idx;
|
|
}
|
|
|
|
void TwxNoteBook::SetTabImage(size_t idx, XVT_IMAGE img)
|
|
{
|
|
if (img != NULL)
|
|
{
|
|
wxImage ico(*wxStaticCast(img, wxImage));
|
|
ico.Rescale(BOOK_ICO_SIZE, BOOK_ICO_SIZE, wxIMAGE_QUALITY_HIGH);
|
|
const wxBitmap bmp(ico);
|
|
SetPageBitmap(idx, bmp);
|
|
}
|
|
else
|
|
SetPageBitmap(idx, wxNullBitmap);
|
|
}
|
|
|
|
int TwxNoteBook::ChangeSelection(size_t tab_no)
|
|
{
|
|
const size_t nSel = GetSelection();
|
|
if (!m_bSuspended && tab_no != nSel)
|
|
{
|
|
m_bSuspended = true;
|
|
SetSelection(tab_no);
|
|
m_bSuspended = false;
|
|
}
|
|
return nSel;
|
|
}
|
|
|
|
long TwxNoteBook::Flags2Style(long flags) const
|
|
{
|
|
long style = wxAUI_NB_TAB_MOVE | wxAUI_NB_SCROLL_BUTTONS;
|
|
if (flags & CTL_FLAG_CENTER_JUST)
|
|
style |= wxAUI_NB_BOTTOM;
|
|
else
|
|
style |= wxAUI_NB_TOP;
|
|
return style;
|
|
}
|
|
|
|
TwxNoteBook::TwxNoteBook(wxWindow *parent, wxWindowID id,
|
|
const wxPoint& pos, const wxSize& size, long flags)
|
|
: wxAuiNotebook(parent, id, pos, size, Flags2Style(flags)), m_bSuspended(false)
|
|
{
|
|
_nice_windows.Put((WINDOW)this, this); // Serve per poter fare la xvt_vobj_destroy
|
|
}
|
|
|
|
TwxNoteBook::~TwxNoteBook()
|
|
{
|
|
m_bSuspended = true;
|
|
_nice_windows.Delete((WINDOW)this);
|
|
}
|
|
|
|
short xvt_notebk_add_page(WINDOW notebk, WINDOW page, const char* title, XVT_IMAGE image, short tab_no)
|
|
{
|
|
short idx = -1;
|
|
if (notebk != NULL_WIN)
|
|
{
|
|
CAST_NOTEBOOK(notebk, nb);
|
|
wxString strTitle = title;
|
|
if (strTitle.IsEmpty() && page != NULL_WIN)
|
|
{
|
|
wxWindow* pg = wxStaticCast((wxObject*)page, wxWindow);
|
|
strTitle = pg->GetLabel();
|
|
}
|
|
idx = nb.AddTab((wxWindow*)page, strTitle, image, tab_no);
|
|
}
|
|
return idx;
|
|
}
|
|
|
|
WINDOW xvt_notebk_get_page(WINDOW notebk, short tab_no)
|
|
{
|
|
WINDOW page = NULL_WIN;
|
|
if (VALID_NOTEBOOK(notebk, tab_no))
|
|
{
|
|
CAST_NOTEBOOK(notebk, nb);
|
|
page = (WINDOW)nb.GetPage(tab_no);
|
|
}
|
|
return page;
|
|
}
|
|
|
|
short xvt_notebk_get_num_tabs(WINDOW notebk)
|
|
{
|
|
short pg = 0;
|
|
if (notebk != NULL_WIN)
|
|
{
|
|
CAST_NOTEBOOK(notebk, nb);
|
|
pg = nb.GetPageCount();
|
|
}
|
|
return pg;
|
|
}
|
|
|
|
void xvt_notebk_rem_page(WINDOW notebk, short page_no)
|
|
{
|
|
WINDOW win = xvt_notebk_get_page(notebk, page_no);
|
|
if (win != NULL_WIN)
|
|
{
|
|
xvt_notebk_rem_tab(notebk, page_no);
|
|
xvt_vobj_destroy(win);
|
|
}
|
|
}
|
|
|
|
void xvt_notebk_rem_tab(WINDOW notebk, short tab_no)
|
|
{
|
|
if (VALID_NOTEBOOK(notebk, tab_no))
|
|
{
|
|
CAST_NOTEBOOK(notebk, nb);
|
|
nb.RemovePage(tab_no);
|
|
}
|
|
}
|
|
|
|
void xvt_notebk_set_front_page(WINDOW notebk, short tab_no)
|
|
{
|
|
if (VALID_NOTEBOOK(notebk, tab_no))
|
|
{
|
|
CAST_NOTEBOOK(notebk, nb);
|
|
wxWindow* w = nb.GetPage(tab_no);
|
|
if (w != NULL)
|
|
{
|
|
nb.ChangeSelection(tab_no); // Non genera evento di cambio pagina!
|
|
if (!w->IsShown()) // A volte succede che la prima pagina sia nascosta!
|
|
w->Show(true);
|
|
}
|
|
}
|
|
}
|
|
|
|
char* xvt_notebk_get_tab_title(WINDOW notebk, short tab_no, char* title, int sz_title)
|
|
{
|
|
if (VALID_NOTEBOOK(notebk, tab_no))
|
|
{
|
|
CAST_NOTEBOOK(notebk, nb);
|
|
wxStrncpy(title, nb.GetPageText(tab_no), sz_title);
|
|
title[sz_title-1] = '\0';
|
|
}
|
|
else
|
|
*title = '\0';
|
|
return title;
|
|
}
|
|
|
|
void xvt_notebk_set_page_title(WINDOW notebk, short tab_no, const char* title)
|
|
{
|
|
WINDOW win = xvt_notebk_get_page(notebk, tab_no);
|
|
if (win != NULL_WIN)
|
|
xvt_vobj_set_title(win, title);
|
|
}
|
|
|
|
void xvt_notebk_set_tab_image(WINDOW notebk, short tab_no, XVT_IMAGE img)
|
|
{
|
|
if (notebk != NULL_WIN && tab_no >= 0)
|
|
{
|
|
CAST_NOTEBOOK(notebk, nb);
|
|
nb.SetTabImage(tab_no, img); // Se img=NULL toglie l'immagine
|
|
}
|
|
}
|
|
|
|
void xvt_notebk_set_tab_icon(WINDOW notebk, short tab_no, int rid)
|
|
{
|
|
const wxString strName = _GetResourceName("Icon", rid);
|
|
XVT_IMAGE img = xvt_image_read(strName);
|
|
xvt_notebk_set_tab_image(notebk, tab_no, img);
|
|
xvt_image_destroy(img);
|
|
}
|
|
|
|
void xvt_notebk_set_tab_title(WINDOW notebk, short tab_no, const char* title)
|
|
{
|
|
if (VALID_NOTEBOOK(notebk, tab_no))
|
|
{
|
|
CAST_NOTEBOOK(notebk, nb);
|
|
const short pc = nb.GetPageCount();
|
|
if (tab_no >= pc)
|
|
nb.AddTab(nb.GetPage(pc-1), title, NULL, pc);
|
|
else
|
|
nb.SetPageText(tab_no, title);
|
|
}
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TreeCtrl interface
|
|
///////////////////////////////////////////////////////////
|
|
|
|
BEGIN_EVENT_TABLE(TwxTreeCtrl, wxTreeCtrl)
|
|
EVT_TREE_ITEM_EXPANDING(wxID_ANY, TwxTreeCtrl::OnExpanding)
|
|
EVT_TREE_ITEM_COLLAPSED(wxID_ANY, TwxTreeCtrl::OnCollapsed)
|
|
EVT_TREE_SEL_CHANGED(wxID_ANY, TwxTreeCtrl::OnSelected)
|
|
EVT_TREE_ITEM_ACTIVATED(wxID_ANY, TwxTreeCtrl::OnActivated)
|
|
EVT_RIGHT_DOWN(TwxTreeCtrl::OnRightDown)
|
|
END_EVENT_TABLE();
|
|
|
|
#define CAST_TREEVIEW(win, tv) TwxTreeCtrl& tv = *wxStaticCast((wxObject*)win, TwxTreeCtrl);
|
|
|
|
struct TwxTreeItemData : public wxTreeItemData
|
|
{
|
|
wxString m_strData; // Assumo sempre una stringa come dati
|
|
};
|
|
|
|
void TwxTreeCtrl::OnExpanding(wxTreeEvent& evt)
|
|
{
|
|
if (!m_nFrozen)
|
|
{
|
|
const wxTreeItemId id = evt.GetItem();
|
|
EVENT e; memset(&e, 0, sizeof(EVENT));
|
|
e.type = E_CONTROL;
|
|
e.v.ctl.id = evt.GetId();
|
|
e.v.ctl.ci.type = WC_TREE;
|
|
e.v.ctl.ci.win = WINDOW(this);
|
|
e.v.ctl.ci.v.treeview.node = id.m_pItem;
|
|
e.v.ctl.ci.v.treeview.expanded = TRUE;
|
|
if (GetChildrenCount(id) == 0) // Trucco perfido ...
|
|
e.v.ctl.ci.v.treeview.collapsed = TRUE; // ... stato indeterminato = EXPANDING
|
|
TwxWindow* win = wxStaticCast(GetParent(), TwxWindow);
|
|
win->DoXvtEvent(e);
|
|
if (GetChildrenCount(id) == 0) // Allora e' proprio vero ...
|
|
SetItemHasChildren(id, false);
|
|
}
|
|
}
|
|
|
|
void TwxTreeCtrl::OnCollapsed(wxTreeEvent& evt)
|
|
{
|
|
if (!m_nFrozen)
|
|
{
|
|
Suspend();
|
|
EVENT e; memset(&e, 0, sizeof(EVENT));
|
|
e.type = E_CONTROL;
|
|
e.v.ctl.id = evt.GetId();
|
|
e.v.ctl.ci.type = WC_TREE;
|
|
e.v.ctl.ci.win = WINDOW(this);
|
|
e.v.ctl.ci.v.treeview.node = evt.GetItem().m_pItem;
|
|
e.v.ctl.ci.v.treeview.collapsed = TRUE;
|
|
TwxWindow* win = wxStaticCast(GetParent(), TwxWindow);
|
|
win->DoXvtEvent(e);
|
|
Resume();
|
|
}
|
|
}
|
|
|
|
void TwxTreeCtrl::OnClick(wxTreeEvent& evt, bool bDouble)
|
|
{
|
|
if (!m_nFrozen)
|
|
{
|
|
Suspend();
|
|
EVENT e; memset(&e, 0, sizeof(EVENT));
|
|
e.type = E_CONTROL;
|
|
e.v.ctl.id = evt.GetId();
|
|
e.v.ctl.ci.type = WC_TREE;
|
|
e.v.ctl.ci.win = WINDOW(this);
|
|
e.v.ctl.ci.v.treeview.node = evt.GetItem().m_pItem;
|
|
if (bDouble)
|
|
e.v.ctl.ci.v.treeview.dbl_click = TRUE;
|
|
else
|
|
e.v.ctl.ci.v.treeview.sgl_click = TRUE;
|
|
TwxWindow* win = wxStaticCast(GetParent(), TwxWindow);
|
|
win->DoXvtEvent(e);
|
|
Resume();
|
|
}
|
|
}
|
|
|
|
void TwxTreeCtrl::OnSelected(wxTreeEvent& evt)
|
|
{ OnClick(evt, false); }
|
|
|
|
void TwxTreeCtrl::OnActivated(wxTreeEvent& evt)
|
|
{ OnClick(evt, true); }
|
|
|
|
void TwxTreeCtrl::OnRightDown(wxMouseEvent& evt)
|
|
{
|
|
TwxWindow* pParent = wxDynamicCast(GetParent(), TwxWindow);
|
|
if (pParent != NULL)
|
|
{
|
|
EVENT e; memset(&e, 0, sizeof(EVENT));
|
|
e.type = E_MOUSE_DOWN;
|
|
e.v.mouse.button = 1;
|
|
e.v.mouse.control = evt.ControlDown();
|
|
e.v.mouse.shift = evt.ShiftDown();
|
|
e.v.mouse.where.h = evt.GetX();
|
|
e.v.mouse.where.v = evt.GetY();
|
|
pParent->DoXvtEvent(e);
|
|
}
|
|
}
|
|
|
|
int TwxTreeCtrl::img2int(XVT_IMAGE xvt_img)
|
|
{
|
|
int i = -1;
|
|
if (xvt_img != NULL)
|
|
{
|
|
i = m_img[xvt_img] - 1; // Ho memorizzato indice+1
|
|
if (i < 0) // Immagine sconosciuta
|
|
{
|
|
const wxImage& img = *(wxImage*)xvt_img;
|
|
wxImageList* il = GetImageList();
|
|
if (il == NULL) // Lista non ancora creata
|
|
{
|
|
il = new wxImageList;
|
|
il->Create(img.GetWidth(), img.GetHeight(), true, 3);
|
|
AssignImageList(il); // DON'T CALL SetImageList!
|
|
}
|
|
else
|
|
{
|
|
int old_w, old_h; il->GetSize(0, old_w, old_h);
|
|
const int new_w = img.GetWidth(), new_h = img.GetHeight();
|
|
if (new_w > old_w) // L'immagine nuova e' troppo grande?
|
|
{
|
|
const int old_ratio = old_w * 100 / old_h;
|
|
const int new_ratio = new_w * 100 / new_h;
|
|
const int old_count = il->GetImageCount();
|
|
wxImageList* nil = new wxImageList;
|
|
nil->Create(new_w, new_h, true, 3*old_count/2);
|
|
for (int k = 0; k < old_count; k++)
|
|
{
|
|
wxImage old = il->GetBitmap(k).ConvertToImage();
|
|
if (old_ratio == new_ratio)
|
|
old.Rescale(new_w, new_h, wxIMAGE_QUALITY_HIGH);
|
|
else
|
|
old.Resize(wxSize(new_w, new_h), wxPoint((new_w-old_w)/2, (new_h-old_h)/2));
|
|
nil->Add(old);
|
|
}
|
|
AssignImageList(il = nil);
|
|
}
|
|
}
|
|
i = il->Add(wxBitmap(img));
|
|
m_img[xvt_img] = i+1; // Memorizzo indice+1
|
|
}
|
|
if (i < 0)
|
|
SORRY_BOX();
|
|
}
|
|
return i;
|
|
}
|
|
|
|
void TwxTreeCtrl::SetNodeImages(const wxTreeItemId& id, XVT_IMAGE item_image,
|
|
XVT_IMAGE collapsed_image, XVT_IMAGE expanded_image)
|
|
{
|
|
const int ii = img2int(item_image);
|
|
if (ii >= 0)
|
|
SetItemImage(id, ii);
|
|
else
|
|
{
|
|
const int ic = img2int(collapsed_image);
|
|
if (ic >= 0)
|
|
{
|
|
SetItemImage(id, ic);
|
|
const int ie = img2int(expanded_image);
|
|
if (ie >= 0)
|
|
SetItemImage(id, ie, wxTreeItemIcon_Selected);
|
|
}
|
|
}
|
|
}
|
|
|
|
wxFont TwxTreeCtrl::GetFont() const
|
|
{
|
|
return m_font.IsOk() ? m_font : wxTreeCtrl::GetFont();
|
|
}
|
|
|
|
void TwxTreeCtrl::Suspend()
|
|
{ m_nFrozen++; }
|
|
|
|
void TwxTreeCtrl::Resume()
|
|
{
|
|
wxASSERT(m_nFrozen > 0);
|
|
if (m_nFrozen > 0)
|
|
m_nFrozen--;
|
|
}
|
|
|
|
TwxTreeCtrl::TwxTreeCtrl(wxWindow *parent, wxWindowID id,
|
|
const wxPoint& pos, const wxSize& size)
|
|
: wxTreeCtrl(parent, id, pos, size, wxTR_HAS_BUTTONS | wxTR_HIDE_ROOT),
|
|
m_nFrozen(0)
|
|
{
|
|
AddRoot("Root");
|
|
}
|
|
|
|
WINDOW xvt_treeview_create(WINDOW parent_win,
|
|
RCT * rct_p, char * title, long ctl_flags,
|
|
long app_data, int ctl_id, XVT_IMAGE item_image,
|
|
XVT_IMAGE collapsed_image, XVT_IMAGE expanded_image,
|
|
long attrs, int line_height)
|
|
{
|
|
WIN_DEF win_def; memset(&win_def, 0, sizeof(WIN_DEF));
|
|
win_def.wtype = WC_TREE;
|
|
win_def.rct = *rct_p;
|
|
win_def.text = title;
|
|
win_def.v.ctl.ctrl_id = ctl_id;
|
|
win_def.v.ctl.flags = ctl_flags;
|
|
WINDOW win = xvt_ctl_create_def(&win_def, parent_win, app_data);
|
|
return win;
|
|
}
|
|
|
|
XVT_TREEVIEW_NODE xvt_treeview_add_child_node(WINDOW win,
|
|
XVT_TREEVIEW_NODE parent, XVT_TREEVIEW_NODE_TYPE type,
|
|
XVT_IMAGE item_image, XVT_IMAGE collapsed_image, XVT_IMAGE expanded_image,
|
|
const char* string, XVT_TREEVIEW_CALLBACK callback, const char* data)
|
|
{
|
|
XVT_TREEVIEW_NODE node = NULL;
|
|
if (win != NULL_WIN)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
TwxTreeItemData* pData = new TwxTreeItemData;
|
|
pData->m_strData = data;
|
|
wxTreeItemId pa(parent);
|
|
if (!pa.IsOk())
|
|
pa = tv.GetRootItem();
|
|
wxTreeItemId id = tv.AppendItem(pa, string, -1, -1, pData);
|
|
if (id.IsOk())
|
|
{
|
|
tv.SetItemHasChildren(pa, true);
|
|
tv.SetItemHasChildren(id, type == XVT_TREEVIEW_NODE_NONTERMINAL);
|
|
tv.SetNodeImages(id, item_image, collapsed_image, expanded_image);
|
|
tv.SetItemFont(id, tv.GetFont());
|
|
node = id.m_pItem;
|
|
}
|
|
}
|
|
return node;
|
|
}
|
|
|
|
XVT_TREEVIEW_NODE xvt_treeview_get_child_node(WINDOW win, XVT_TREEVIEW_NODE parent_node,
|
|
int position)
|
|
{
|
|
XVT_TREEVIEW_NODE child_node = NULL;
|
|
if (win != NULL_WIN && position >= 0)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
wxTreeItemId parent(parent_node);
|
|
if (!parent.IsOk())
|
|
parent = tv.GetRootItem();
|
|
|
|
if (parent.IsOk() && position < (int)tv.GetChildrenCount(parent))
|
|
{
|
|
wxTreeItemIdValue cookie;
|
|
wxTreeItemId id;
|
|
int i = -1;
|
|
for (id = tv.GetFirstChild(parent, cookie), i = -1;
|
|
i < position && id.IsOk(); id = tv.GetNextChild(parent, cookie), i++);
|
|
child_node = id.m_pItem;
|
|
}
|
|
}
|
|
return child_node;
|
|
}
|
|
|
|
const char* xvt_treeview_get_node_data(WINDOW win, XVT_TREEVIEW_NODE node)
|
|
{
|
|
const char* data = NULL;
|
|
if (win != NULL_WIN && node != NULL)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
const wxTreeItemId id(node);
|
|
TwxTreeItemData* pData = (TwxTreeItemData*)tv.GetItemData(id);
|
|
if (pData != NULL)
|
|
data = (const char*)pData->m_strData;
|
|
}
|
|
return data;
|
|
}
|
|
|
|
void xvt_treeview_destroy_node(WINDOW win, XVT_TREEVIEW_NODE node)
|
|
{
|
|
if (win != NULL_WIN && node != NULL)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
wxTreeItemId id(node);
|
|
tv.Delete(id);
|
|
}
|
|
}
|
|
|
|
BOOLEAN xvt_treeview_expand_node(WINDOW win, XVT_TREEVIEW_NODE node, BOOLEAN recurse)
|
|
{
|
|
BOOLEAN ok = (win != NULL_WIN) && (node != NULL);
|
|
if (ok)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
tv.Suspend();
|
|
const wxTreeItemId id(node);
|
|
if (recurse)
|
|
tv.ExpandAllChildren(id);
|
|
else
|
|
tv.Expand(id);
|
|
tv.Resume();
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
XVT_TREEVIEW_NODE xvt_treeview_get_root_node(WINDOW win)
|
|
{
|
|
XVT_TREEVIEW_NODE pRoot = NULL;
|
|
if (win != NULL_WIN)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
const wxTreeItemId id = tv.GetRootItem();
|
|
pRoot = id.m_pItem;
|
|
}
|
|
return pRoot;
|
|
}
|
|
|
|
XVT_TREEVIEW_NODE xvt_treeview_get_selected_node(WINDOW win)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
const wxTreeItemId id = tv.GetSelection();
|
|
return id.m_pItem;
|
|
}
|
|
|
|
BOOLEAN xvt_treeview_remove_child_node(WINDOW win, XVT_TREEVIEW_NODE node)
|
|
{
|
|
BOOLEAN ok = (win != NULL_WIN) && (node != NULL);
|
|
if (ok)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
const wxTreeItemId id(node);
|
|
if (id == tv.GetRootItem())
|
|
tv.DeleteAllItems();
|
|
else
|
|
{
|
|
tv.Suspend();
|
|
tv.Delete(id);
|
|
tv.Resume();
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
BOOLEAN xvt_treeview_remove_node_children(WINDOW win, XVT_TREEVIEW_NODE node)
|
|
{
|
|
BOOLEAN ok = FALSE;
|
|
if (win != NULL_WIN)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
tv.Suspend();
|
|
wxTreeItemId id(node);
|
|
if (!id.IsOk())
|
|
id = tv.GetRootItem();
|
|
tv.DeleteChildren(id);
|
|
tv.Resume();
|
|
ok = TRUE;
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
void xvt_treeview_resume(WINDOW win)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
tv.Resume();
|
|
}
|
|
|
|
void xvt_treeview_select_node(WINDOW win, XVT_TREEVIEW_NODE node, BOOLEAN sel)
|
|
{
|
|
if (win != NULL_WIN && node != NULL)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
const wxTreeItemId id(node);
|
|
if (sel)
|
|
{
|
|
tv.Suspend();
|
|
tv.SelectItem(id, true);
|
|
tv.EnsureVisible(id);
|
|
tv.Resume();
|
|
}
|
|
else
|
|
tv.SelectItem(id, false);
|
|
}
|
|
}
|
|
|
|
void xvt_treeview_set_node_images(WINDOW win, XVT_TREEVIEW_NODE node, XVT_IMAGE item_image,
|
|
XVT_IMAGE collapsed_image, XVT_IMAGE expanded_image)
|
|
{
|
|
if (win != NULL_WIN && node != NULL)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
const wxTreeItemId id(node);
|
|
tv.SetNodeImages(id, item_image, collapsed_image, expanded_image);
|
|
}
|
|
}
|
|
|
|
void xvt_treeview_set_node_string(WINDOW win, XVT_TREEVIEW_NODE node, const char* text)
|
|
{
|
|
if (win != NULL_WIN && node != NULL)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
const wxTreeItemId id(node);
|
|
tv.SetItemText(id, text);
|
|
}
|
|
}
|
|
|
|
void xvt_treeview_suspend(WINDOW win)
|
|
{
|
|
CAST_TREEVIEW(win, tv);
|
|
tv.Suspend();
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// TwxOutlookBar
|
|
///////////////////////////////////////////////////////////
|
|
|
|
BEGIN_EVENT_TABLE(TwxOutlookBar, wxVListBox)
|
|
EVT_COMMAND(wxID_ANY, wxEVT_COMMAND_LISTBOX_SELECTED, TwxOutlookBar::OnSelected)
|
|
EVT_COMMAND(wxID_ANY, wxEVT_COMMAND_LISTBOX_DOUBLECLICKED, TwxOutlookBar::OnSelected)
|
|
EVT_MOTION(TwxOutlookBar::OnMouseMove)
|
|
EVT_MOUSE_CAPTURE_LOST(TwxOutlookBar::OnMouseCaptureLost)
|
|
END_EVENT_TABLE()
|
|
|
|
static wxAuiDockArt* GetArtist(const wxWindow* pWindow)
|
|
{
|
|
wxAuiDockArt* pArtist = NULL;
|
|
const wxAuiManager* pManager = wxAuiManager::GetManager(pWindow->GetParent());
|
|
if (pManager != NULL)
|
|
pArtist = pManager->GetArtProvider();
|
|
return pArtist;
|
|
}
|
|
|
|
static const wxColour ModulateColour(const wxColour& col, int percent)
|
|
{
|
|
int k = 0;
|
|
if (percent > 0)
|
|
k = 255;
|
|
else
|
|
percent = -percent;
|
|
const int inverse = 100-percent;
|
|
int r = ((k * percent) + (col.Red() * inverse)) / 100;
|
|
int g = ((k * percent) + (col.Green() * inverse)) / 100;
|
|
int b = ((k * percent) + (col.Blue() * inverse)) / 100;
|
|
return wxColour(r, g, b);
|
|
}
|
|
|
|
static wxColour DarkerColor(const wxColour& col, int percent = 20)
|
|
{ return ModulateColour(col, -percent); }
|
|
|
|
static wxColour LighterColor(const wxColour& col, int percent = 20)
|
|
{ return ModulateColour(col, +percent); }
|
|
|
|
void TwxOutlookBar::OnDrawBackground(wxDC& dc, const wxRect& rect, size_t n) const
|
|
{
|
|
wxColour color1, color2;
|
|
if (n == m_nHovering)
|
|
{
|
|
if (n == GetSelection())
|
|
{
|
|
color1 = wxColour(232,127,8);
|
|
color2 = wxColour(247,218,124);
|
|
}
|
|
else
|
|
{
|
|
color1 = wxColour(255,255,220);
|
|
color2 = wxColour(247,192,91);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (n == GetSelection())
|
|
{
|
|
color1 = wxColour(251,230,148); // Colori predefiniti di Outlook
|
|
color2 = wxColour(238,149, 21);
|
|
}
|
|
else
|
|
{
|
|
color1 = LighterColor(wxSystemSettings::GetColour(wxSYS_COLOUR_INACTIVECAPTION));
|
|
color2 = DarkerColor(wxSystemSettings::GetColour(wxSYS_COLOUR_ACTIVECAPTION));
|
|
}
|
|
}
|
|
dc.GradientFillLinear(rect, color1, color2, wxDOWN);
|
|
}
|
|
|
|
void TwxOutlookBar::OnDrawItem(wxDC& dc, const wxRect& rect, size_t n) const
|
|
{
|
|
const int nSide = rect.height;
|
|
const TwxOutlookItem& oi = m_item[n];
|
|
int nTextOffset = 4;
|
|
if (oi.m_nIconId > 0)
|
|
{
|
|
const wxIcon& ico = _GetIconResource(oi.m_nIconId);
|
|
const wxSize szIco(ico.GetWidth(), ico.GetHeight());
|
|
dc.DrawIcon(ico, rect.x+nTextOffset, rect.y+(nSide-szIco.y)/2);
|
|
nTextOffset += nTextOffset+szIco.x;
|
|
}
|
|
|
|
dc.SetFont(GetFont()); // Imposta il font predefinito per questo controllo
|
|
|
|
wxColour color = wxSystemSettings::GetColour(wxSYS_COLOUR_CAPTIONTEXT);
|
|
dc.SetTextForeground(color);
|
|
|
|
const wxSize szText = dc.GetTextExtent(oi.m_strText);
|
|
dc.DrawText(oi.m_strText, rect.x+nTextOffset, rect.y+(nSide-szText.y)/2);
|
|
}
|
|
|
|
wxCoord TwxOutlookBar::OnMeasureItem(size_t n) const
|
|
{
|
|
const int nItems = GetItemCount();
|
|
wxCoord nHeight = 36;
|
|
if (nItems > 1)
|
|
{
|
|
const wxSize sz = GetSize();
|
|
nHeight = max(sz.y / nItems, nHeight);
|
|
}
|
|
return nHeight;
|
|
}
|
|
|
|
void TwxOutlookBar::OnMouseMove(wxMouseEvent& evt)
|
|
{
|
|
int nHover = HitTest(evt.GetPosition());
|
|
if (m_bCaptured && nHover != wxNOT_FOUND)
|
|
{
|
|
const wxRect rect = GetClientRect();
|
|
if (!rect.Contains(evt.GetPosition()))
|
|
nHover = wxNOT_FOUND;
|
|
}
|
|
|
|
if (nHover == wxNOT_FOUND)
|
|
{
|
|
if (m_bCaptured)
|
|
{
|
|
m_bCaptured = false;
|
|
ReleaseMouse();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!m_bCaptured)
|
|
{
|
|
m_bCaptured = true;
|
|
CaptureMouse();
|
|
}
|
|
}
|
|
|
|
if (nHover != m_nHovering)
|
|
{
|
|
const int nWasHovering = m_nHovering;
|
|
m_nHovering = nHover;
|
|
if (nWasHovering != wxNOT_FOUND)
|
|
RefreshLine(nWasHovering);
|
|
if (m_nHovering != wxNOT_FOUND)
|
|
RefreshLine(m_nHovering);
|
|
}
|
|
}
|
|
|
|
void TwxOutlookBar::OnMouseCaptureLost(wxMouseCaptureLostEvent&)
|
|
{
|
|
m_bCaptured = false;
|
|
if (m_nHovering != wxNOT_FOUND)
|
|
{
|
|
const int nWasHovering = m_nHovering;
|
|
m_nHovering = wxNOT_FOUND;
|
|
RefreshLine(nWasHovering);
|
|
}
|
|
}
|
|
|
|
void TwxOutlookBar::OnSelected(wxCommandEvent& evt)
|
|
{
|
|
EVENT e; memset(&e, 0, sizeof(EVENT));
|
|
e.type = E_CONTROL;
|
|
e.v.ctl.id = evt.GetId();
|
|
e.v.ctl.ci.type = WC_OUTLOOKBAR;
|
|
e.v.ctl.ci.win = WINDOW(this);
|
|
e.v.ctl.ci.v.lbox.dbl_click = evt.GetEventType() == wxEVT_COMMAND_LISTBOX_DOUBLECLICKED;
|
|
TwxWindow* win = (TwxWindow*)GetParent();
|
|
win->DoXvtEvent(e);
|
|
}
|
|
|
|
int TwxOutlookBar::Add(short nIconId, const wxString strText, int nFlags)
|
|
{
|
|
int i = GetItemCount();
|
|
const bool ok = i < MAX_ITEMS-1;
|
|
if (ok)
|
|
{
|
|
m_item[i].m_nIconId = nIconId;
|
|
m_item[i].m_strText = strText;
|
|
m_item[i].m_nFlags = nFlags;
|
|
SetItemCount(i+1);
|
|
}
|
|
else
|
|
i = -1;
|
|
return i;
|
|
}
|
|
|
|
TwxOutlookBar::TwxOutlookBar(wxWindow *parent, wxWindowID id,
|
|
const wxPoint& pos, const wxSize& size, long style)
|
|
: wxVListBox(parent, id, pos, size, style),
|
|
m_bCaptured(false), m_nHovering(wxNOT_FOUND)
|
|
{
|
|
SetItemCount(0);
|
|
}
|
|
|
|
TwxOutlookBar::~TwxOutlookBar()
|
|
{
|
|
if (HasCapture())
|
|
ReleaseMouse();
|
|
}
|
|
|
|
|
|
int xvt_list_add_item(WINDOW win, short icon, const char* text, int flags)
|
|
{
|
|
int n = -1;
|
|
if (win != NULL_WIN)
|
|
{
|
|
TwxOutlookBar* olb = (TwxOutlookBar*)win;
|
|
n = olb->Add(icon, text, flags);
|
|
}
|
|
return n;
|
|
}
|
|
|
|
BOOLEAN xvt_list_clear(WINDOW win)
|
|
{
|
|
BOOLEAN ok = win != NULL_WIN;
|
|
if (ok)
|
|
{
|
|
TwxOutlookBar* olb = (TwxOutlookBar*)win;
|
|
olb->Clear();
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
BOOLEAN xvt_list_get_sel_index(WINDOW win)
|
|
{
|
|
int sel = -1;
|
|
BOOLEAN ok = win != NULL_WIN;
|
|
if (ok)
|
|
{
|
|
TwxOutlookBar* olb = (TwxOutlookBar*)win;
|
|
sel = olb->GetSelection();
|
|
}
|
|
return sel;
|
|
}
|
|
|
|
BOOLEAN xvt_list_set_sel(WINDOW win, int index, BOOLEAN select)
|
|
{
|
|
BOOLEAN ok = win != NULL_WIN;
|
|
if (ok)
|
|
{
|
|
TwxOutlookBar* olb = (TwxOutlookBar*)win;
|
|
if (select)
|
|
olb->SetSelection(index);
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
///////////////////////////////////////////////////////////
|
|
// ToolBar
|
|
///////////////////////////////////////////////////////////
|
|
|
|
class TwxToolBar : public wxToolBar
|
|
{
|
|
protected:
|
|
DECLARE_EVENT_TABLE()
|
|
void OnTool(wxCommandEvent& evt);
|
|
|
|
public:
|
|
TwxToolBar(wxWindow* parent, wxWindowID id, const wxPoint& pos,
|
|
const wxSize& size, long style);
|
|
};
|
|
|
|
BEGIN_EVENT_TABLE(TwxToolBar, wxToolBar)
|
|
EVT_TOOL(wxID_ANY, TwxToolBar::OnTool)
|
|
END_EVENT_TABLE();
|
|
|
|
void TwxToolBar::OnTool(wxCommandEvent& evt)
|
|
{
|
|
EVENT e; memset(&e, 0, sizeof(EVENT));
|
|
e.type = E_CONTROL;
|
|
e.v.ctl.id = evt.GetId();
|
|
e.v.ctl.ci.type = WC_ICON; // WC_PUSHBUTTON entra in conflitto coi bottoni
|
|
e.v.ctl.ci.win = WINDOW(this);
|
|
TwxWindow* win = (TwxWindow*)GetParent();
|
|
win->DoXvtEvent(e);
|
|
}
|
|
|
|
TwxToolBar::TwxToolBar(wxWindow* parent, wxWindowID id, const wxPoint& pos,
|
|
const wxSize& size, long style)
|
|
: wxToolBar(parent, id, pos, size, style)
|
|
{ }
|
|
|
|
static wxToolBar* Win2Bar(WINDOW win)
|
|
{
|
|
return wxDynamicCast((wxWindow*)win, wxToolBar);
|
|
}
|
|
|
|
BOOLEAN xvt_toolbar_add_control(WINDOW win, int cid, TOOL_TYPE type, const char *title,
|
|
int ico, int cust_width, int idx)
|
|
{
|
|
BOOLEAN ok = FALSE;
|
|
wxToolBar* ptb = Win2Bar(win);
|
|
if (ptb != NULL)
|
|
{
|
|
wxToolBar& tb = *ptb;
|
|
switch (type)
|
|
{
|
|
case TOOL_SEPARATOR:
|
|
if (idx < 0)
|
|
ok = tb.AddSeparator() != NULL;
|
|
else
|
|
ok = tb.InsertSeparator(idx) != NULL;
|
|
break;
|
|
default:
|
|
{
|
|
const wxBitmap& bmp = _GetToolResource(ico, tb.GetToolBitmapSize().y);
|
|
wxString cap, tip;
|
|
wxChar acc = 0;
|
|
for (const char* t = title; *t; t++)
|
|
{
|
|
if (*t == '~' || *t == '&')
|
|
{
|
|
cap << '&';
|
|
acc = toupper(*(t+1));
|
|
}
|
|
else
|
|
{
|
|
cap << *t;
|
|
tip << *t;
|
|
}
|
|
}
|
|
if (acc > '\0')
|
|
{
|
|
if (acc >= 'A' && acc <= 'Z')
|
|
tip << "\n(Alt+" << acc << ")";
|
|
}
|
|
if (idx < 0)
|
|
ok = tb.AddTool(cid, cap, bmp, wxNullBitmap, wxItemKind(type), tip) != NULL;
|
|
else
|
|
ok = tb.InsertTool(idx, cid, cap, bmp, wxNullBitmap, wxItemKind(type), tip) != NULL;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
return ok;
|
|
}
|
|
|
|
WINDOW xvt_toolbar_create(int cid, int left, int top, int right, int bottom, long nFlags, WINDOW parent)
|
|
{
|
|
long nStyle = wxNO_BORDER | wxTB_NODIVIDER;
|
|
if (nFlags & CTL_FLAG_PASSWORD)
|
|
nStyle |= wxTB_TEXT | wxTB_FLAT;
|
|
|
|
const wxPoint ptPos(left, top);
|
|
wxSize szSize(right-left, bottom-top);
|
|
|
|
int nIcoSize = 24;
|
|
if (bottom > 0)
|
|
{
|
|
nStyle |= wxTB_HORIZONTAL;
|
|
nIcoSize = RoundToIcon(szSize.y);
|
|
}
|
|
else
|
|
{
|
|
nStyle |= wxTB_VERTICAL;
|
|
nIcoSize = RoundToIcon(szSize.x);
|
|
}
|
|
|
|
TwxToolBar* tb = new TwxToolBar((wxWindow*)parent, cid, ptPos, wxDefaultSize, nStyle);
|
|
tb->SetToolBitmapSize(wxSize(nIcoSize, nIcoSize));
|
|
return (WINDOW)tb;
|
|
}
|
|
|
|
void xvt_toolbar_enable_control(WINDOW win, int cid, BOOLEAN on)
|
|
{
|
|
wxToolBar* ptb = Win2Bar(win);
|
|
if (ptb != NULL && cid > 0)
|
|
ptb->EnableTool(cid, on != 0);
|
|
}
|
|
|
|
BOOLEAN xvt_toolbar_set_last_tool(WINDOW win, int id)
|
|
{
|
|
BOOLEAN bMoved = FALSE;
|
|
wxToolBar* ptb = Win2Bar(win);
|
|
if (ptb != NULL) // Is a valid toolbar?
|
|
{
|
|
const int pos = ptb->GetToolPos(id);
|
|
if (pos >= 0)
|
|
{
|
|
const int nCount = ptb->GetToolsCount();
|
|
if (pos < nCount-1)
|
|
{
|
|
wxToolBarToolBase* tool = ptb->RemoveTool(id);
|
|
ptb->InsertTool(nCount-1, tool);
|
|
}
|
|
bMoved = TRUE;
|
|
}
|
|
}
|
|
return bMoved;
|
|
}
|
|
|
|
void xvt_toolbar_realize(WINDOW win)
|
|
{
|
|
wxToolBar* ptb = Win2Bar(win);
|
|
if (ptb != NULL) // Is a valid toolbar?
|
|
{
|
|
ptb->Realize(); // Update tools
|
|
wxAuiPaneInfo* pi = LockPane(win);
|
|
if (pi != NULL)
|
|
{
|
|
const wxSize szBar = ptb->GetSize();
|
|
if (pi->min_size.x < szBar.x || pi->min_size.y < szBar.y)
|
|
{
|
|
pi->MinSize(szBar);
|
|
pi->BestSize(szBar);
|
|
UnlockPane(win);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void xvt_toolbar_show_control(WINDOW win, int cid, BOOLEAN on)
|
|
{
|
|
wxToolBar* ptb = Win2Bar(win);
|
|
if (ptb != NULL && cid > 0)
|
|
ptb->EnableTool(cid, on != 0); // Per ora non so come si faccia
|
|
}
|
|
|
|
void xvt_dwin_draw_tool(WINDOW win, int x, int y, int rid, int size)
|
|
{
|
|
const wxBitmap& bmp = _GetToolResource(rid, size);
|
|
if (bmp.IsOk())
|
|
{
|
|
wxDC& dc = GetTDCMapper().GetDC(win);
|
|
dc.DrawBitmap(bmp, x, y);
|
|
}
|
|
}
|