From be38f2e534d1134803af9fc0e1028d8229fda0e9 Mon Sep 17 00:00:00 2001 From: kohait Date: Tue, 28 Dec 2010 16:50:38 +0000 Subject: [PATCH] bazaar: adding: AutoScroller, CtrlFinder, CtrlProp(erties), Iter(ator) interface, LogPosCtrl, PointCtrl, PopUpC, RectCtrl, Styler, ValueCtrl, WithEnterAction git-svn-id: svn://ultimatepp.org/upp/trunk@2942 f0d560ea-af0d-0410-9eb7-867de7ffcac7 --- bazaar/AutoScroller/AutoScroller.cpp | 3 + bazaar/AutoScroller/AutoScroller.h | 36 ++ bazaar/AutoScroller/AutoScroller.hpp | 56 +++ bazaar/AutoScroller/AutoScroller.upp | 10 + bazaar/AutoScroller/init | 4 + bazaar/AutoScrollerTest/AutoScrollerTest.h | 31 ++ bazaar/AutoScrollerTest/AutoScrollerTest.iml | 6 + bazaar/AutoScrollerTest/AutoScrollerTest.lay | 12 + bazaar/AutoScrollerTest/AutoScrollerTest.upp | 15 + bazaar/AutoScrollerTest/init | 5 + bazaar/AutoScrollerTest/main.cpp | 41 ++ bazaar/CtrlFinder/CtrlFinder.cpp | 24 ++ bazaar/CtrlFinder/CtrlFinder.h | 62 +++ bazaar/CtrlFinder/CtrlFinder.upp | 9 + bazaar/CtrlFinder/init | 4 + bazaar/CtrlProp/Ctrl.cpp | 46 +++ bazaar/CtrlProp/CtrlProp.cpp | 29 ++ bazaar/CtrlProp/CtrlProp.h | 170 ++++++++ bazaar/CtrlProp/CtrlProp.hpp | 10 + bazaar/CtrlProp/CtrlProp.upp | 20 + bazaar/CtrlProp/CtrlPropEdit.cpp | 192 +++++++++ bazaar/CtrlProp/CtrlPropEdit.lay | 18 + bazaar/CtrlProp/EditCtrl.cpp | 191 +++++++++ bazaar/CtrlProp/PushCtrl.cpp | 52 +++ bazaar/CtrlProp/SliderCtrl.cpp | 18 + bazaar/CtrlProp/StaticCtrl.cpp | 65 +++ bazaar/CtrlProp/TextEdit.cpp | 53 +++ bazaar/CtrlProp/init | 6 + bazaar/CtrlPropTest/CtrlPropTest.h | 50 +++ bazaar/CtrlPropTest/CtrlPropTest.lay | 45 +++ bazaar/CtrlPropTest/CtrlPropTest.upp | 20 + bazaar/CtrlPropTest/edit.cpp | 40 ++ bazaar/CtrlPropTest/find.cpp | 34 ++ bazaar/CtrlPropTest/hook.cpp | 26 ++ bazaar/CtrlPropTest/init | 7 + bazaar/CtrlPropTest/main.cpp | 46 +++ bazaar/CtrlPropTest/misc.cpp | 123 ++++++ bazaar/Iter/Iter.cpp | 1 + bazaar/Iter/Iter.h | 323 +++++++++++++++ bazaar/Iter/Iter.upp | 10 + bazaar/Iter/init | 5 + bazaar/IterTest/IterTest.h | 27 ++ bazaar/IterTest/IterTest.lay | 3 + bazaar/IterTest/IterTest.upp | 14 + bazaar/IterTest/init | 5 + bazaar/IterTest/main.cpp | 147 +++++++ bazaar/LogPosCtrl/LogPosCtrl.cpp | 317 +++++++++++++++ bazaar/LogPosCtrl/LogPosCtrl.h | 85 ++++ bazaar/LogPosCtrl/LogPosCtrl.lay | 21 + bazaar/LogPosCtrl/LogPosCtrl.upp | 11 + bazaar/LogPosCtrl/LogPosPopUp.lay | 21 + bazaar/LogPosCtrl/init | 5 + bazaar/LogPosCtrlTest/LogPosCtrlTest.h | 26 ++ bazaar/LogPosCtrlTest/LogPosCtrlTest.lay | 8 + bazaar/LogPosCtrlTest/LogPosCtrlTest.upp | 14 + bazaar/LogPosCtrlTest/main.cpp | 25 ++ bazaar/PointCtrl/PointCtrl.cpp | 159 ++++++++ bazaar/PointCtrl/PointCtrl.h | 89 +++++ bazaar/PointCtrl/PointCtrl.upp | 10 + bazaar/PointCtrl/init | 5 + bazaar/PointCtrlTest/PointCtrlTest.h | 29 ++ bazaar/PointCtrlTest/PointCtrlTest.lay | 7 + bazaar/PointCtrlTest/PointCtrlTest.upp | 14 + bazaar/PointCtrlTest/init | 5 + bazaar/PointCtrlTest/main.cpp | 63 +++ bazaar/PopUpC/PopUpC.cpp | 57 +++ bazaar/PopUpC/PopUpC.h | 23 ++ bazaar/PopUpC/PopUpC.upp | 9 + bazaar/PopUpC/init | 4 + bazaar/PopUpTest/PopUpTest.h | 26 ++ bazaar/PopUpTest/PopUpTest.lay | 10 + bazaar/PopUpTest/PopUpTest.upp | 14 + bazaar/PopUpTest/init | 5 + bazaar/PopUpTest/main.cpp | 38 ++ bazaar/RectCtrl/RectCtrl.cpp | 218 ++++++++++ bazaar/RectCtrl/RectCtrl.h | 104 +++++ bazaar/RectCtrl/RectCtrl.upp | 10 + bazaar/RectCtrl/icons.iml | 33 ++ bazaar/RectCtrl/init | 4 + bazaar/RectCtrlTest/RectCtrlTest.h | 20 + bazaar/RectCtrlTest/RectCtrlTest.lay | 4 + bazaar/RectCtrlTest/RectCtrlTest.upp | 14 + bazaar/RectCtrlTest/main.cpp | 19 + bazaar/Styler/Styler.cpp | 288 ++++++++++++++ bazaar/Styler/Styler.h | 44 +++ bazaar/Styler/Styler.lay | 52 +++ bazaar/Styler/Styler.upp | 12 + bazaar/Styler/StylerCtrls.iml | 187 +++++++++ bazaar/Styler/init | 4 + bazaar/Styler/unused.cpp | 371 ++++++++++++++++++ bazaar/StylerTest/AllCtrlTest.iml | 8 + bazaar/StylerTest/AllCtrlTest.lay | 49 +++ bazaar/StylerTest/MyCtrls.iml | 186 +++++++++ bazaar/StylerTest/StylerTest.h | 36 ++ bazaar/StylerTest/StylerTest.iml | 8 + bazaar/StylerTest/StylerTest.lay | 49 +++ bazaar/StylerTest/StylerTest.upp | 15 + bazaar/StylerTest/init | 5 + bazaar/StylerTest/main.cpp | 122 ++++++ bazaar/ValueCtrl/ValueCtrl.cpp | 165 ++++++++ bazaar/ValueCtrl/ValueCtrl.h | 138 +++++++ bazaar/ValueCtrl/ValueCtrl.lay | 6 + bazaar/ValueCtrl/ValueCtrl.upp | 12 + bazaar/ValueCtrl/ValuePopUp.lay | 6 + bazaar/ValueCtrl/init | 6 + bazaar/ValueCtrlTest/ValueCtrlTest.h | 33 ++ bazaar/ValueCtrlTest/ValueCtrlTest.lay | 5 + bazaar/ValueCtrlTest/ValueCtrlTest.upp | 14 + bazaar/ValueCtrlTest/main.cpp | 26 ++ bazaar/WithEnterAction/WithEnterAction.cpp | 3 + bazaar/WithEnterAction/WithEnterAction.h | 29 ++ bazaar/WithEnterAction/WithEnterAction.upp | 9 + .../WithEnterActionTest/WithEnterActionTest.h | 26 ++ .../WithEnterActionTest.lay | 4 + .../WithEnterActionTest.upp | 14 + bazaar/WithEnterActionTest/main.cpp | 19 + 116 files changed, 5591 insertions(+) create mode 100644 bazaar/AutoScroller/AutoScroller.cpp create mode 100644 bazaar/AutoScroller/AutoScroller.h create mode 100644 bazaar/AutoScroller/AutoScroller.hpp create mode 100644 bazaar/AutoScroller/AutoScroller.upp create mode 100644 bazaar/AutoScroller/init create mode 100644 bazaar/AutoScrollerTest/AutoScrollerTest.h create mode 100644 bazaar/AutoScrollerTest/AutoScrollerTest.iml create mode 100644 bazaar/AutoScrollerTest/AutoScrollerTest.lay create mode 100644 bazaar/AutoScrollerTest/AutoScrollerTest.upp create mode 100644 bazaar/AutoScrollerTest/init create mode 100644 bazaar/AutoScrollerTest/main.cpp create mode 100644 bazaar/CtrlFinder/CtrlFinder.cpp create mode 100644 bazaar/CtrlFinder/CtrlFinder.h create mode 100644 bazaar/CtrlFinder/CtrlFinder.upp create mode 100644 bazaar/CtrlFinder/init create mode 100644 bazaar/CtrlProp/Ctrl.cpp create mode 100644 bazaar/CtrlProp/CtrlProp.cpp create mode 100644 bazaar/CtrlProp/CtrlProp.h create mode 100644 bazaar/CtrlProp/CtrlProp.hpp create mode 100644 bazaar/CtrlProp/CtrlProp.upp create mode 100644 bazaar/CtrlProp/CtrlPropEdit.cpp create mode 100644 bazaar/CtrlProp/CtrlPropEdit.lay create mode 100644 bazaar/CtrlProp/EditCtrl.cpp create mode 100644 bazaar/CtrlProp/PushCtrl.cpp create mode 100644 bazaar/CtrlProp/SliderCtrl.cpp create mode 100644 bazaar/CtrlProp/StaticCtrl.cpp create mode 100644 bazaar/CtrlProp/TextEdit.cpp create mode 100644 bazaar/CtrlProp/init create mode 100644 bazaar/CtrlPropTest/CtrlPropTest.h create mode 100644 bazaar/CtrlPropTest/CtrlPropTest.lay create mode 100644 bazaar/CtrlPropTest/CtrlPropTest.upp create mode 100644 bazaar/CtrlPropTest/edit.cpp create mode 100644 bazaar/CtrlPropTest/find.cpp create mode 100644 bazaar/CtrlPropTest/hook.cpp create mode 100644 bazaar/CtrlPropTest/init create mode 100644 bazaar/CtrlPropTest/main.cpp create mode 100644 bazaar/CtrlPropTest/misc.cpp create mode 100644 bazaar/Iter/Iter.cpp create mode 100644 bazaar/Iter/Iter.h create mode 100644 bazaar/Iter/Iter.upp create mode 100644 bazaar/Iter/init create mode 100644 bazaar/IterTest/IterTest.h create mode 100644 bazaar/IterTest/IterTest.lay create mode 100644 bazaar/IterTest/IterTest.upp create mode 100644 bazaar/IterTest/init create mode 100644 bazaar/IterTest/main.cpp create mode 100644 bazaar/LogPosCtrl/LogPosCtrl.cpp create mode 100644 bazaar/LogPosCtrl/LogPosCtrl.h create mode 100644 bazaar/LogPosCtrl/LogPosCtrl.lay create mode 100644 bazaar/LogPosCtrl/LogPosCtrl.upp create mode 100644 bazaar/LogPosCtrl/LogPosPopUp.lay create mode 100644 bazaar/LogPosCtrl/init create mode 100644 bazaar/LogPosCtrlTest/LogPosCtrlTest.h create mode 100644 bazaar/LogPosCtrlTest/LogPosCtrlTest.lay create mode 100644 bazaar/LogPosCtrlTest/LogPosCtrlTest.upp create mode 100644 bazaar/LogPosCtrlTest/main.cpp create mode 100644 bazaar/PointCtrl/PointCtrl.cpp create mode 100644 bazaar/PointCtrl/PointCtrl.h create mode 100644 bazaar/PointCtrl/PointCtrl.upp create mode 100644 bazaar/PointCtrl/init create mode 100644 bazaar/PointCtrlTest/PointCtrlTest.h create mode 100644 bazaar/PointCtrlTest/PointCtrlTest.lay create mode 100644 bazaar/PointCtrlTest/PointCtrlTest.upp create mode 100644 bazaar/PointCtrlTest/init create mode 100644 bazaar/PointCtrlTest/main.cpp create mode 100644 bazaar/PopUpC/PopUpC.cpp create mode 100644 bazaar/PopUpC/PopUpC.h create mode 100644 bazaar/PopUpC/PopUpC.upp create mode 100644 bazaar/PopUpC/init create mode 100644 bazaar/PopUpTest/PopUpTest.h create mode 100644 bazaar/PopUpTest/PopUpTest.lay create mode 100644 bazaar/PopUpTest/PopUpTest.upp create mode 100644 bazaar/PopUpTest/init create mode 100644 bazaar/PopUpTest/main.cpp create mode 100644 bazaar/RectCtrl/RectCtrl.cpp create mode 100644 bazaar/RectCtrl/RectCtrl.h create mode 100644 bazaar/RectCtrl/RectCtrl.upp create mode 100644 bazaar/RectCtrl/icons.iml create mode 100644 bazaar/RectCtrl/init create mode 100644 bazaar/RectCtrlTest/RectCtrlTest.h create mode 100644 bazaar/RectCtrlTest/RectCtrlTest.lay create mode 100644 bazaar/RectCtrlTest/RectCtrlTest.upp create mode 100644 bazaar/RectCtrlTest/main.cpp create mode 100644 bazaar/Styler/Styler.cpp create mode 100644 bazaar/Styler/Styler.h create mode 100644 bazaar/Styler/Styler.lay create mode 100644 bazaar/Styler/Styler.upp create mode 100644 bazaar/Styler/StylerCtrls.iml create mode 100644 bazaar/Styler/init create mode 100644 bazaar/Styler/unused.cpp create mode 100644 bazaar/StylerTest/AllCtrlTest.iml create mode 100644 bazaar/StylerTest/AllCtrlTest.lay create mode 100644 bazaar/StylerTest/MyCtrls.iml create mode 100644 bazaar/StylerTest/StylerTest.h create mode 100644 bazaar/StylerTest/StylerTest.iml create mode 100644 bazaar/StylerTest/StylerTest.lay create mode 100644 bazaar/StylerTest/StylerTest.upp create mode 100644 bazaar/StylerTest/init create mode 100644 bazaar/StylerTest/main.cpp create mode 100644 bazaar/ValueCtrl/ValueCtrl.cpp create mode 100644 bazaar/ValueCtrl/ValueCtrl.h create mode 100644 bazaar/ValueCtrl/ValueCtrl.lay create mode 100644 bazaar/ValueCtrl/ValueCtrl.upp create mode 100644 bazaar/ValueCtrl/ValuePopUp.lay create mode 100644 bazaar/ValueCtrl/init create mode 100644 bazaar/ValueCtrlTest/ValueCtrlTest.h create mode 100644 bazaar/ValueCtrlTest/ValueCtrlTest.lay create mode 100644 bazaar/ValueCtrlTest/ValueCtrlTest.upp create mode 100644 bazaar/ValueCtrlTest/main.cpp create mode 100644 bazaar/WithEnterAction/WithEnterAction.cpp create mode 100644 bazaar/WithEnterAction/WithEnterAction.h create mode 100644 bazaar/WithEnterAction/WithEnterAction.upp create mode 100644 bazaar/WithEnterActionTest/WithEnterActionTest.h create mode 100644 bazaar/WithEnterActionTest/WithEnterActionTest.lay create mode 100644 bazaar/WithEnterActionTest/WithEnterActionTest.upp create mode 100644 bazaar/WithEnterActionTest/main.cpp diff --git a/bazaar/AutoScroller/AutoScroller.cpp b/bazaar/AutoScroller/AutoScroller.cpp new file mode 100644 index 000000000..eb57adb6d --- /dev/null +++ b/bazaar/AutoScroller/AutoScroller.cpp @@ -0,0 +1,3 @@ +#include "AutoScroller.hpp" + +template class AutoScroller; diff --git a/bazaar/AutoScroller/AutoScroller.h b/bazaar/AutoScroller/AutoScroller.h new file mode 100644 index 000000000..997e4cf2f --- /dev/null +++ b/bazaar/AutoScroller/AutoScroller.h @@ -0,0 +1,36 @@ +#ifndef _AutoScroller_AutoScroller_h_ +#define _AutoScroller_AutoScroller_h_ + +#include + +using namespace Upp; + +template +class AutoScroller + : public ParentCtrl +{ +public: + typedef AutoScroller CLASSNAME; + AutoScroller(); + +public: + virtual void Layout(); + + void SetPaneSize(const Size & sz); + Size GetPaneSize() const { return pane.GetSize(); } + + void EnableScroll(bool b = true); + void DisableScroll() { EnableScroll(false); } + bool IsEnabledScroll() const { return scroll.x.IsEnabled() || scroll.y.IsEnabled(); } + + C pane; + +protected: + void OnScroll(); + +private: + ScrollBars scroll; +}; + + +#endif diff --git a/bazaar/AutoScroller/AutoScroller.hpp b/bazaar/AutoScroller/AutoScroller.hpp new file mode 100644 index 000000000..2cb9fca88 --- /dev/null +++ b/bazaar/AutoScroller/AutoScroller.hpp @@ -0,0 +1,56 @@ +#ifndef _AutoScroller_AutoScroller_hpp_ +#define _AutoScroller_AutoScroller_hpp_ + +#include "AutoScroller.h" + +template +AutoScroller::AutoScroller() +{ + EnableScroll(); + scroll.WhenScroll = THISBACK(OnScroll); + Add(pane.TopPos(0).LeftPos(0)); + SetPaneSize(GetSize()); +} + +template +void AutoScroller::OnScroll() +{ + Point tl(-scroll.GetX(), -scroll.GetY()); + Rect r = pane.GetRect(); + Rect _r(tl, r.GetSize()); + pane.SetRect(_r); +} + +template +void AutoScroller::Layout() +{ + Size sz = GetSize(); + if(sz != scroll.GetPage()) + scroll.SetPage(sz); +} + +template +void AutoScroller::SetPaneSize(const Size & sz) +{ + Ctrl::LogPos logp; + logp.x = ParentCtrl::PosLeft(0, sz.cx); + logp.y = ParentCtrl::PosTop(0, sz.cy); + pane.SetPos(logp); + scroll.SetTotal(sz); +} + +template +void AutoScroller::EnableScroll(bool b) +{ + if(b) + AddFrame(scroll.AutoHide()); + else + RemoveFrame(scroll); + scroll.x.Enable(b); + scroll.y.Enable(b); + return; + scroll.Show(b); + Layout(); +} + +#endif diff --git a/bazaar/AutoScroller/AutoScroller.upp b/bazaar/AutoScroller/AutoScroller.upp new file mode 100644 index 000000000..2a45be736 --- /dev/null +++ b/bazaar/AutoScroller/AutoScroller.upp @@ -0,0 +1,10 @@ +description "A templateable autoscrolling control container\377"; + +uses + CtrlLib; + +file + AutoScroller.h, + AutoScroller.hpp, + AutoScroller.cpp; + diff --git a/bazaar/AutoScroller/init b/bazaar/AutoScroller/init new file mode 100644 index 000000000..d7404843b --- /dev/null +++ b/bazaar/AutoScroller/init @@ -0,0 +1,4 @@ +#ifndef _AutoScroller_icpp_init_stub +#define _AutoScroller_icpp_init_stub +#include "CtrlLib/init" +#endif diff --git a/bazaar/AutoScrollerTest/AutoScrollerTest.h b/bazaar/AutoScrollerTest/AutoScrollerTest.h new file mode 100644 index 000000000..3d9afd31b --- /dev/null +++ b/bazaar/AutoScrollerTest/AutoScrollerTest.h @@ -0,0 +1,31 @@ +#ifndef _AutoScrollerTest_AutoScrollerTest_h +#define _AutoScrollerTest_AutoScrollerTest_h + +#include + +using namespace Upp; + +#define LAYOUTFILE +#include + +#define IMAGEFILE +#include + +//if use only ParentCtrl as pane +//#include +//if use custom panes +#include + +class AutoScrollerTest : public WithAutoScrollerTestLayout { +public: + typedef AutoScrollerTest CLASSNAME; + AutoScrollerTest(); + + void Toggle(); + + AutoScroller > sc; + //WithTestLay view; +}; + +#endif + diff --git a/bazaar/AutoScrollerTest/AutoScrollerTest.iml b/bazaar/AutoScrollerTest/AutoScrollerTest.iml new file mode 100644 index 000000000..c44d98cf8 --- /dev/null +++ b/bazaar/AutoScrollerTest/AutoScrollerTest.iml @@ -0,0 +1,6 @@ +PREMULTIPLIED +IMAGE_ID(blaa) + +IMAGE_BEGIN_DATA +IMAGE_DATA(120,156,99,16,96,16,96,24,5,163,96,20,140,2,0,133,109,0,33,0,0,0,0,0,0,0,0,0,0,0,0,0) +IMAGE_END_DATA(32, 1) diff --git a/bazaar/AutoScrollerTest/AutoScrollerTest.lay b/bazaar/AutoScrollerTest/AutoScrollerTest.lay new file mode 100644 index 000000000..eea3a5118 --- /dev/null +++ b/bazaar/AutoScrollerTest/AutoScrollerTest.lay @@ -0,0 +1,12 @@ +LAYOUT(AutoScrollerTestLayout, 200, 100) +END_LAYOUT + +LAYOUT(TestLay, 640, 440) + ITEM(DocEdit, doc0, LeftPosZ(12, 68).TopPosZ(12, 44)) + ITEM(DocEdit, doc1, LeftPosZ(12, 164).BottomPosZ(12, 176)) + ITEM(DocEdit, doc3, RightPosZ(16, 176).TopPosZ(16, 92)) + ITEM(DocEdit, doc2, RightPosZ(12, 176).BottomPosZ(12, 92)) + ITEM(ProgressIndicator, dv___4, LeftPosZ(112, 440).TopPosZ(156, 24)) + ITEM(Button, tg, SetLabel(t_("Toggle")).LeftPosZ(84, 56).TopPosZ(40, 15)) +END_LAYOUT + diff --git a/bazaar/AutoScrollerTest/AutoScrollerTest.upp b/bazaar/AutoScrollerTest/AutoScrollerTest.upp new file mode 100644 index 000000000..488290045 --- /dev/null +++ b/bazaar/AutoScrollerTest/AutoScrollerTest.upp @@ -0,0 +1,15 @@ +description "how to extend a control with automatic scroll bars\377"; + +uses + CtrlLib, + AutoScroller; + +file + AutoScrollerTest.h, + main.cpp, + AutoScrollerTest.lay, + AutoScrollerTest.iml; + +mainconfig + "" = "GUI MT"; + diff --git a/bazaar/AutoScrollerTest/init b/bazaar/AutoScrollerTest/init new file mode 100644 index 000000000..07a5e9fec --- /dev/null +++ b/bazaar/AutoScrollerTest/init @@ -0,0 +1,5 @@ +#ifndef _ScrollBarEx_icpp_init_stub +#define _ScrollBarEx_icpp_init_stub +#include "CtrlLib/init" +#include "AutoScroller/init" +#endif diff --git a/bazaar/AutoScrollerTest/main.cpp b/bazaar/AutoScrollerTest/main.cpp new file mode 100644 index 000000000..76da10704 --- /dev/null +++ b/bazaar/AutoScrollerTest/main.cpp @@ -0,0 +1,41 @@ +#include "AutoScrollerTest.h" + +#define IMAGEFILE +#include + +void AutoScrollerTest::Toggle() +{ + sc.EnableScroll(!sc.IsEnabledScroll()); +} + +AutoScrollerTest::AutoScrollerTest() +{ + CtrlLayout(*this, "Window title"); + Sizeable().Zoomable(); + + CtrlLayout(sc.pane); + + //determine the total size of the scrolling pane + //or updaten it, i.e. after CtrlLayout + sc.SetPaneSize(sc.pane.GetSize()); + + //add content to the scrolling pane, if not CtrlLayouted + //sc.pane.Add(view); + + //add the AutoScroller itself to application + Add(sc.SizePos()); + + //do other setup stuff + sc.pane.tg <<= THISBACK(Toggle); + + sc.pane.doc0 <<= "doc0"; + sc.pane.doc1 <<= "doc1"; + sc.pane.doc2 <<= "doc2"; + sc.pane.doc3 <<= "doc3"; +} + +GUI_APP_MAIN +{ + AutoScrollerTest().Run(); +} + diff --git a/bazaar/CtrlFinder/CtrlFinder.cpp b/bazaar/CtrlFinder/CtrlFinder.cpp new file mode 100644 index 000000000..392c3b355 --- /dev/null +++ b/bazaar/CtrlFinder/CtrlFinder.cpp @@ -0,0 +1,24 @@ +#include "CtrlFinder.h" + +Ctrl* GetCtrl(Ctrl* parent, Point p, dword keyflags) +{ + Ctrl* c = parent->GetFirstChild(); + while(c) + { + Rect r = c->GetRect(); + if(r.Contains(p)) return c; + c = c->GetNext(); + } + return NULL; +} + +void CtrlFinder::OnCtrlLeft(Point p, dword keyflags) +{ + Ctrl* c = GetCtrlFromParent(p, keyflags); + if(c) WhenLeftDown(*c, p, keyflags); +} +void CtrlFinder::OnCtrlRight(Point p, dword keyflags) +{ + Ctrl* c = GetCtrlFromParent(p, keyflags); + if(c) WhenRightDown(*c, p, keyflags); +} diff --git a/bazaar/CtrlFinder/CtrlFinder.h b/bazaar/CtrlFinder/CtrlFinder.h new file mode 100644 index 000000000..95e623f94 --- /dev/null +++ b/bazaar/CtrlFinder/CtrlFinder.h @@ -0,0 +1,62 @@ +#ifndef _CtrlFinder_CtrlFinder_h +#define _CtrlFinder_CtrlFinder_h + +#include + +using namespace Upp; + +class MouseHookCtrl : public ParentCtrl +{ +public: + typedef MouseHookCtrl CLASSNAME; + MouseHookCtrl() : minsize(Null) { Update(); } + + void SetMinSize(Size sz) { minsize = sz; } + virtual Rect GetVoidRect()const { return GetSize(); } + virtual Size GetStdSize() const { return GetMinSize(); } + virtual Size GetMinSize() const { return IsNull(minsize) ? Ctrl::GetMinSize() : minsize; } + + virtual void LeftDown(Point p, dword keyflags) { WhenLeftDown(p,keyflags); } + virtual void RightDown(Point p, dword keyflags) { WhenRightDown(p,keyflags); } + virtual void LeftUp(Point p, dword keyflags) { WhenLeftUp(p,keyflags); } + virtual void RightUp(Point p, dword keyflags) { WhenRightUp(p,keyflags); } + virtual void MouseMove(Point p, dword keyflags) { WhenMouseMove(p,keyflags); } + virtual void LeftRepeat(Point p, dword keyflags) { WhenLeftRepeat(p,keyflags); } + virtual void RightRepeat(Point p, dword keyflags) { WhenRightRepeat(p,keyflags); } + + virtual void Updated() { IgnoreMouse(!IsEnabled()); } + + Callback2 WhenLeftDown; + Callback2 WhenRightDown; + Callback2 WhenLeftUp; + Callback2 WhenRightUp; + Callback2 WhenMouseMove; + Callback2 WhenLeftRepeat; + Callback2 WhenRightRepeat; + +protected: + Size minsize; +}; + +Ctrl* GetCtrl(Ctrl* parent, Point p, dword keyflags); + +class CtrlFinder : public MouseHookCtrl +{ +public: + typedef CtrlFinder CLASSNAME; + typedef MouseHookCtrl R; + CtrlFinder() { R::WhenLeftDown = THISBACK(OnCtrlLeft); R::WhenRightDown = THISBACK(OnCtrlRight);} + + Ctrl* GetCtrl(Point p, dword keyflags) { return ::GetCtrl(this, p, keyflags); } + Ctrl* GetCtrlFromParent(Point p, dword keyflags) { return ::GetCtrl(GetParent(), p, keyflags); } + + Callback3 WhenLeftDown; + Callback3 WhenRightDown; + +protected: + void OnCtrlLeft(Point p, dword keyflags); + void OnCtrlRight(Point p, dword keyflags); +}; + +#endif + diff --git a/bazaar/CtrlFinder/CtrlFinder.upp b/bazaar/CtrlFinder/CtrlFinder.upp new file mode 100644 index 000000000..360261293 --- /dev/null +++ b/bazaar/CtrlFinder/CtrlFinder.upp @@ -0,0 +1,9 @@ +description "Find a Ctrl using a transparent Hook Ctrl, see CtrlPropTest\377"; + +uses + CtrlLib; + +file + CtrlFinder.h, + CtrlFinder.cpp; + diff --git a/bazaar/CtrlFinder/init b/bazaar/CtrlFinder/init new file mode 100644 index 000000000..0f00d3f75 --- /dev/null +++ b/bazaar/CtrlFinder/init @@ -0,0 +1,4 @@ +#ifndef _CtrlFinder_icpp_init_stub +#define _CtrlFinder_icpp_init_stub +#include "CtrlLib/init" +#endif diff --git a/bazaar/CtrlProp/Ctrl.cpp b/bazaar/CtrlProp/Ctrl.cpp new file mode 100644 index 000000000..f2153fc60 --- /dev/null +++ b/bazaar/CtrlProp/Ctrl.cpp @@ -0,0 +1,46 @@ +#include "CtrlProp.h" +#include + +bool PropSetData(Ctrl& o, const Value& v) { o.SetData(v); return true; } +bool PropGetData(const Ctrl& o, Value& v) { v = o.GetData(); return true; } +bool PropEnable(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.Enable(v); return true; } +bool PropIsEnabled(const Ctrl& o, Value& v) { v = o.IsEnabled(); return true; } +bool PropShow(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.Show(v); return true; } +bool PropIsVisible(const Ctrl& o, Value& v) { v = o.IsVisible(); return true; } +bool PropEditable(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.SetEditable(v); return true; } +bool PropIsEditable(const Ctrl& o, Value& v) { v = o.IsEditable(); return true; } +bool PropFocus(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; bool b = v; if(b) o.SetFocus(); else if(o.GetParent()) o.GetParent()->SetFocus(); return true; } +bool PropHasFocus(const Ctrl& o, Value& v) { v = o.HasFocus(); return true; } +bool PropModify(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; bool b = v; if(b) o.SetModify(); else o.ResetModify(); return true; } +bool PropIsModified(const Ctrl& o, Value& v) { v = o.IsModified(); return true; } +bool PropSetTip(Ctrl& o, const Value& v) { o.Tip(AsString(v)); return true; } +bool PropGetTip(const Ctrl& o, Value& v) { v = o.GetTip(); return true; } +bool PropWantFocus(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.WantFocus(v); return true; } +bool PropIsWantFocus(const Ctrl& o, Value& v) { v = o.IsWantFocus(); return true; } +bool PropInitFocus(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.InitFocus(v); return true; } +bool PropIsInitFocus(const Ctrl& o, Value& v) { v = o.IsInitFocus(); return true; } +bool PropBackPaint(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.BackPaint(((bool(v))?(Ctrl::FULLBACKPAINT):(Ctrl::NOBACKPAINT))); return true; } +bool PropIsBackPaint(const Ctrl& o, Value& v) { v = bool(o.GetBackPaint()!=Ctrl::NOBACKPAINT); return true; } +bool PropTransparent(Ctrl& o, const Value& v) { if(!IsNumber(v)) return false; o.Transparent(v); return true; } +bool PropIsTransparent(const Ctrl& o, Value& v) { v = o.IsTransparent(); return true; } + +bool PropRefresh(Ctrl& o, const Value& v) { o.Refresh(); return true; } + +bool PropSetLogPos(Ctrl& o, const Value& v) { if(!v.Is()) return false; o.SetPos(RawValue::Extract(v)); return true; } +bool PropGetLogPos(const Ctrl& o, Value& v) { v = RawToValue(o.GetPos()); return true; } + +CTRL_PROPERTIES(Ctrl, RecurseDone) +PROPERTY("data", PropSetData, PropGetData) +PROPERTY("enable", PropEnable, PropIsEnabled) +PROPERTY("show", PropShow, PropIsVisible) +PROPERTY("editable", PropEditable, PropIsEditable) +PROPERTY("logpos", PropSetLogPos, PropGetLogPos) +PROPERTY("focus", PropFocus, PropHasFocus) +PROPERTY("modify", PropModify, PropIsModified) +PROPERTY("tip", PropSetTip, PropGetTip) +PROPERTY("wantfocus", PropWantFocus, PropIsWantFocus) +PROPERTY("initFocus", PropInitFocus, PropIsInitFocus) +PROPERTY("backpaint", PropBackPaint, PropIsBackPaint) +PROPERTY("transparent", PropTransparent, PropIsTransparent) +//PROPERTY_SET("refresh", PropRefresh) +END_CTRL_PROPERTIES diff --git a/bazaar/CtrlProp/CtrlProp.cpp b/bazaar/CtrlProp/CtrlProp.cpp new file mode 100644 index 000000000..fe836cfb2 --- /dev/null +++ b/bazaar/CtrlProp/CtrlProp.cpp @@ -0,0 +1,29 @@ +#include "CtrlProp.h" + +void AddToValueArray(Value& v, const Vector& k) +{ + if(!v.Is()) + { + v = ValueArray(Vector()); + } + ValueArray va = v; + Vector& vv = const_cast&>(va.Get()); + for(int i = 0; i < k.GetCount(); i++) + vv << k[i]; +} + +bool GetSetPropRecurseDone(Ctrl& c, const String& p, Value& v, int f) { return false; } + +VectorMap& pmap() +{ + static VectorMap _; + return _; +} + +bool Property(Ctrl& c, const String& p, Value& v, int f) +{ + int i = pmap().Find(String(typeid(c).name())); + if(i<0) return false; + return pmap()[i](c,p,v,f); +} + diff --git a/bazaar/CtrlProp/CtrlProp.h b/bazaar/CtrlProp/CtrlProp.h new file mode 100644 index 000000000..af961a1cb --- /dev/null +++ b/bazaar/CtrlProp/CtrlProp.h @@ -0,0 +1,170 @@ +#ifndef _CtrlProp_CtrlProp_h +#define _CtrlProp_CtrlProp_h + +#include +using namespace Upp; + +enum +{ + PROPGET = 0, + PROPSET = 1, +}; + +template struct GetTyper{ + typedef bool (*H)(const C&, Value&); + typedef Gate2 Handler; + static ArrayMap& map() { static ArrayMap _; return _; } +}; +template struct SetTyper{ + typedef bool (*H)(C&, const Value&); + typedef Gate2 Handler; + static ArrayMap& map() { static ArrayMap _; return _; } +}; + +typedef Gate4 ParamHandler; +VectorMap& pmap(); +#define REGISTERPROPS(CTRL) pmap().GetAdd(String(typeid(CTRL).name())) = callback(&GetSetProp##CTRL) + +void AddToValueArray(Value& v, const Vector& k); +bool GetSetPropRecurseDone(Ctrl& c, const String& p, Value& v, int f); + +#define DEC_CTRL_PROPERTIES(CTRL) \ +bool GetSetProp##CTRL(Ctrl& c, const String& p, Value& v, int f) \ + + +#define CTRL_PROPERTIES(CTRL, BASE) \ +DEC_CTRL_PROPERTIES(CTRL); \ +DEC_CTRL_PROPERTIES(BASE); \ +INITBLOCK { REGISTERPROPS(CTRL); } \ +DEC_CTRL_PROPERTIES(CTRL) \ +{ \ + typedef CTRL _CTRL_; \ + if(0) { __base: return GetSetProp##BASE(c,p,v,f); } \ + ONCELOCK { \ + + +#define END_CTRL_PROPERTIES \ + } \ + _CTRL_* pc = dynamic_cast<_CTRL_*>(&c); \ + if(!pc) return false; \ + _CTRL_& o = *pc; \ + \ + ArrayMap::Handler>& s = SetTyper<_CTRL_>::map(); \ + ArrayMap::Handler>& g = GetTyper<_CTRL_>::map(); \ + if(f&PROPSET) \ + { \ + int i = s.Find(p); if(i>=0) return s[i](o, v); \ + } \ + else \ + { \ + int i = g.Find(p); if(i>=0) return g[i](o, v); \ + if(p == "listset") AddToValueArray(v, s.GetKeys()); \ + else if(p == "listget") AddToValueArray(v, g.GetKeys()); \ + } \ + goto __base; \ +} \ + + +#define EXT_PROPERTY_SET(CTRL, name, fset) \ + SetTyper::map().GetAdd(name) = callback((SetTyper::H)&fset); \ + + +#define EXT_PROPERTY_GET(CTRL, name, fget) \ + GetTyper::map().GetAdd(name) = callback((GetTyper::H)&fget); \ + + +#define EXT_PROPERTY(CTRL, name, fset, fget) \ + EXT_PROPERTY_SET(CTRL, name, fset) \ + EXT_PROPERTY_GET(CTRL, name, fget) \ + + +#define PROPERTY_SET(name, fset) \ + EXT_PROPERTY_SET(_CTRL_, name, fset) \ + + +#define PROPERTY_GET(name, fset) \ + EXT_PROPERTY_GET(_CTRL_, name, fset) \ + + +#define PROPERTY(name, fset, fget) \ + EXT_PROPERTY_SET(_CTRL_, name, fset) \ + EXT_PROPERTY_GET(_CTRL_, name, fget) \ + + + +#define EXT_UNPROPERTY_SET(CTRL, name) \ + SetTyper::map().RemoveKey(name); \ + +#define EXT_UNPROPERTY_GET(CTRL, name) \ + GetTyper::map().RemoveKey(name); \ + +#define EXT_UNPROPERTY(CTRL, name) \ + EXT_UNPROPERTY_SET(CTRL, name) \ + EXT_UNPROPERTY_GET(CTRL, name) \ + + +#define UNPROPERTY_SET(name, fset) \ + EXT_UNPROPERTY_SET(_CTRL_, name, fset) \ + + +#define UNPROPERTY_GET(name, fset) \ + EXT_UNPROPERTY_GET(_CTRL_, name, fset) \ + + +#define UNPROPERTY(name, fset, fget) \ + EXT_UNPROPERTY_SET(_CTRL_, name, fset) \ + EXT_UNPROPERTY_GET(_CTRL_, name, fget) \ + + +bool Property(Ctrl& c, const String& p, Value& v, int f); +inline bool SetProperty(Ctrl& c, const String& p, const Value& v) { return Property(c,p,const_cast(v),PROPSET); } +inline bool GetProperty(const Ctrl& c, const String& p, Value& v) { return Property(const_cast(c),p,v,PROPGET); } + +//helpers for editing + +#include +using namespace Upp; + +#include +#include + +VectorMap BidirProps(Ctrl& c); + +#define LAYOUTFILE +#include + +class PropList : public WithPropListLay +{ +public: + typedef PropList CLASSNAME; + PropList(); + + void Evaluate(Ctrl& e); + void PopUp(Ctrl* owner, Ctrl& e) { Evaluate(e); PopUpC::PopUp(owner); } +}; + +class PropEdit : public WithPropEditLay +{ +public: + typedef PropEdit CLASSNAME; + PropEdit(); + + virtual void Deactivate() {} //let other popups open + + void Evaluate(Ctrl& e); + void PopUp(Ctrl* owner, Ctrl& e) { Evaluate(e); PopUpC::PopUp(owner); } + + virtual void Rejector(); + virtual void Acceptor(); + +public: + void OnUpdateRow(); + + Ctrl* pe; + ArrayMap > vsav; +}; + + + +#endif + diff --git a/bazaar/CtrlProp/CtrlProp.hpp b/bazaar/CtrlProp/CtrlProp.hpp new file mode 100644 index 000000000..d8e101961 --- /dev/null +++ b/bazaar/CtrlProp/CtrlProp.hpp @@ -0,0 +1,10 @@ +#ifndef _CtrlProp_CtrlProp_hpp +#define _CtrlProp_CtrlProp_hpp + +#include "CtrlProp.h" + +//type specific maps for the handlers +template ArrayMap >& wpmap() { static ArrayMap > _; return _; } +template ArrayMap >& rpmap() { static ArrayMap > _; return _; } + +#endif diff --git a/bazaar/CtrlProp/CtrlProp.upp b/bazaar/CtrlProp/CtrlProp.upp new file mode 100644 index 000000000..d121bc7d5 --- /dev/null +++ b/bazaar/CtrlProp/CtrlProp.upp @@ -0,0 +1,20 @@ +description "Ctrl properties editing in a common interface, see CtrlPropTest\377"; + +uses + CtrlLib, + LogPosCtrl, + ValueCtrl; + +file + CtrlProp.h, + CtrlProp.cpp, + CtrlPropEdit.cpp, + CtrlPropEdit.lay, + Props readonly separator, + Ctrl.cpp, + PushCtrl.cpp, + EditCtrl.cpp, + TextEdit.cpp, + StaticCtrl.cpp, + SliderCtrl.cpp; + diff --git a/bazaar/CtrlProp/CtrlPropEdit.cpp b/bazaar/CtrlProp/CtrlPropEdit.cpp new file mode 100644 index 000000000..c321ebf97 --- /dev/null +++ b/bazaar/CtrlProp/CtrlPropEdit.cpp @@ -0,0 +1,192 @@ +#include "CtrlProp.h" + +VectorMap BidirProps(Ctrl& c) +{ + VectorMap is; + Value vs; + GetProperty(c, "listset", vs); + if(!vs.Is()) + return is; + ValueArray vas = vs; + + for(int i = 0; i < vas.GetCount(); i++) + { + int& m = is.GetAdd(vas.Get(i), 0); + m |= 1; + } + + Value vg; + GetProperty(c, "listget", vg); + if(!vg.Is()) + return is; + ValueArray vag = vg; + + for(int i = 0; i < vag.GetCount(); i++) + { + int& m = is.GetAdd(vag.Get(i), 0); + m |= 2; + } + + return is; +} + +PropList::PropList() +{ + CtrlLayout(*this); + ok <<= THISBACK(Acceptor); + cancel <<= THISBACK(Rejector); +} + +void PropList::Evaluate(Ctrl& e) +{ + Value v; + bool b; + String t; + + b = GetProperty(e, "listset", v); + ValueArray vs = v; + t << "Set Properties: (" << vs.GetCount() << ")\n" << v; + gl.SetData(t); + + v = Value(); + b = GetProperty(e, "listget", v); + t.Clear(); + ValueArray vg = v; + t << "Get Properties: (" << vg.GetCount() << ")\n"; + { + for(int i = 0; i < vg.GetCount(); i++) + { + String s = vg.Get(i); + Value v; + t << "{" << s << "} = "; + b = GetProperty(e, s, v); + if(b) t << v; + else t << "##ERR##"; + t << "\n"; + } + } + sl.SetData(t); +} + +PropEdit::PropEdit() +{ + CtrlLayout(*this); + ok <<= THISBACK(Acceptor); + cancel <<= THISBACK(Rejector); + + ac.AddColumn("Property"); + ac.AddColumn("Value"); + //ac.WhenUpdateRow = THISBACK(OnUpdateRow); +} + +void PropEdit::Evaluate(Ctrl& e) +{ + pe = &e; + ac.Clear(); + vsav.Clear(); + + VectorMap is = BidirProps(e); + + int k = 0; + for(int i = 0; i < is.GetCount(); i++) + { + String tag = is.GetKey(i); + int& m = is[i]; + + Value v; + if(m&2) + { + if(!GetProperty(e, tag, v)) + continue; + } + ac.Set(k, 0, tag); + ac.Set(k, 1, v); //forwarded to controls + + switch(m) + { + case 3: //bidir + { + Tuple2& tv = vsav.Add(tag); + tv.a = false; + tv.b = v; + + Ctrl* pc; + if(!v.IsNull()) + { + pc = DefaultValueEditor(v); + { + LogPosCtrl* ple = dynamic_cast(pc); + if(ple) + ple->Set(e); + } + } + else pc = new ValueCtrl(); + pc->WhenAction = THISBACK(OnUpdateRow); + + ac.SetCtrl(k, 1, pc); //owned + ++k; + } + break; + case 2: //getter only + { + StaticText* pc = new StaticText(); + pc->SetText(AsString(v)); + + ac.SetCtrl(k, 1, pc); //owned + ++k; + } + break; + case 1: //setter only + { + //FIXME needs to know which type + //meanwhile, we let user choose + ValueCtrl* pc = new ValueCtrl(); + pc->WhenAction = THISBACK(OnUpdateRow); + + ac.SetCtrl(k, 1, pc); //owned + ++k; + } + break; + default: + break; + } + } +} + +void PropEdit::OnUpdateRow() +{ + if(!pe) return; + if(!ac.IsCursor()) return; //FIXME Option Focus issue + SetProperty(*pe, ac.Get(0), ac.Get(1)); + vsav.GetAdd(ac.Get(0)).a = true; //dirty + pe->UpdateRefresh(); +} + +void PropEdit::Rejector() +{ + if(pe) + { + for(int i = 0; i < vsav.GetCount(); i++) + if(vsav[i].a) + SetProperty(*pe, vsav.GetKey(i), vsav[i].b); + } + pe = NULL; + ac.Clear(); + vsav.Clear(); + + PopUpC::Rejector(); +} + +void PropEdit::Acceptor() +{ + if(0 && pe) //FIXME when direct editing works, we can spare this out + { + for(int i = 0; i < ac.GetCount(); i++) + SetProperty(*pe, ac.Get(i, 0), ac.Get(i, 1)); + } + pe = NULL; + ac.Clear(); + vsav.Clear(); + + PopUpC::Acceptor(); +} diff --git a/bazaar/CtrlProp/CtrlPropEdit.lay b/bazaar/CtrlProp/CtrlPropEdit.lay new file mode 100644 index 000000000..8ac4a148b --- /dev/null +++ b/bazaar/CtrlProp/CtrlPropEdit.lay @@ -0,0 +1,18 @@ +LAYOUT(PropListLay, 400, 200) + ITEM(DocEdit, gl, WantFocus(false).SetEditable(false).LeftPosZ(0, 168).VSizePosZ(0, 20)) + ITEM(DocEdit, sl, WantFocus(false).SetEditable(false).HSizePosZ(168, 0).VSizePosZ(0, 20)) + ITEM(Button, cancel, SetLabel(t_("Cancel")).RightPosZ(0, 56).BottomPosZ(0, 20)) + ITEM(Button, ok, SetLabel(t_("Ok")).RightPosZ(56, 56).BottomPosZ(0, 20)) +END_LAYOUT + +LAYOUT(PropEditLay, 400, 200) + ITEM(ArrayCtrl, ac, HSizePosZ(0, 0).VSizePosZ(0, 20)) + ITEM(Button, cancel, SetLabel(t_("Cancel")).RightPosZ(0, 56).BottomPosZ(0, 20)) + ITEM(Button, ok, SetLabel(t_("Ok")).RightPosZ(56, 56).BottomPosZ(0, 20)) +END_LAYOUT + +LAYOUT(ValuePopUp, 400, 200) + ITEM(Button, ok, SetLabel(t_("OK")).RightPosZ(56, 56).BottomPosZ(0, 20)) + ITEM(Button, cancel, SetLabel(t_("Cancel")).RightPosZ(0, 56).BottomPosZ(0, 20)) +END_LAYOUT + diff --git a/bazaar/CtrlProp/EditCtrl.cpp b/bazaar/CtrlProp/EditCtrl.cpp new file mode 100644 index 000000000..9201f03cb --- /dev/null +++ b/bazaar/CtrlProp/EditCtrl.cpp @@ -0,0 +1,191 @@ +#include "CtrlProp.h" +#include + +//EditField + +bool PropSetPassword(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.Password(v); return true; } +bool PropGetPassword(const EditField& o, Value& v) { v = o.IsPassword(); return true; } +bool PropSetAutoFormat(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.AutoFormat(v); return true; } +bool PropGetAutoFormat(const EditField& o, Value& v) { v = o.IsAutoFormat(); return true; } +bool PropSetClickSelect(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.ClickSelect(v); return true; } +bool PropGetClickSelect(const EditField& o, Value& v) { v = o.IsClickSelect(); return true; } +bool PropSetInitCaps(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.InitCaps(v); return true; } +bool PropGetInitCaps(const EditField& o, Value& v) { v = o.IsInitCaps(); return true; } +bool PropSetMaxChars(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.MaxChars(v); return true; } +bool PropGetMaxChars(const EditField& o, Value& v) { v = o.GetMaxChars(); return true; } +bool PropSetNoBackground(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.NoBackground(v); return true; } +bool PropGetNoBackground(const EditField& o, Value& v) { v = o.IsNoBackground(); return true; } +bool PropSetAlignRight(EditField& o, const Value& v) { if(!IsNumber(v)) return false; o.AlignRight(v); return true; } +bool PropGetAlignRight(const EditField& o, Value& v) { v = o.IsAlignRight(); return true; } + +CTRL_PROPERTIES(EditField, Ctrl) +PROPERTY("password", PropSetPassword, PropGetPassword) +PROPERTY("autoformat", PropSetAutoFormat, PropGetAutoFormat) +PROPERTY("clickselect", PropSetClickSelect, PropGetClickSelect) +PROPERTY("initcaps", PropSetInitCaps, PropGetInitCaps) +PROPERTY("maxchars", PropSetMaxChars, PropGetMaxChars) +PROPERTY("nobackground", PropSetNoBackground, PropGetNoBackground) +PROPERTY("alignright", PropSetAlignRight, PropGetAlignRight) +END_CTRL_PROPERTIES + +//EditString + +bool PropSetMaxLen(EditString& o, const Value& v) { if(!IsNumber(v)) return false; o.MaxLen(v); return true; } +bool PropGetMaxLen(const EditString& o, Value& v) { v = o.GetMaxLength(); return true; } +bool PropSetTrimLeft(EditString& o, const Value& v) { if(!IsNumber(v)) return false; o.TrimLeft(v); return true; } +bool PropGetTrimLeft(const EditString& o, Value& v) { v = o.IsTrimLeft(); return true; } +bool PropSetTrimRight(EditString& o, const Value& v) { if(!IsNumber(v)) return false; o.TrimRight(v); return true; } +bool PropGetTrimRight(const EditString& o, Value& v) { v = o.IsTrimRight(); return true; } +bool PropSetNotNull(EditString& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; } +bool PropGetNotNull(const EditString& o, Value& v) { v = o.IsNotNull(); return true; } + +CTRL_PROPERTIES(EditString, EditField) +PROPERTY("maxlen", PropSetMaxLen, PropGetMaxLen) +PROPERTY("trimleft", PropSetTrimLeft, PropGetTrimLeft) +PROPERTY("trimrigth", PropSetTrimRight, PropGetTrimRight) +PROPERTY("notnull", PropSetNotNull, PropGetNotNull) +END_CTRL_PROPERTIES + +//EditInt + +bool PropSetMin(EditInt& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; } +bool PropGetMin(const EditInt& o, Value& v) { v = o.GetMin(); return true; } +bool PropSetMax(EditInt& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; } +bool PropGetMax(const EditInt& o, Value& v) { v = o.GetMax(); return true; } +bool PropSetNotNull(EditInt& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; } +bool PropGetNotNull(const EditInt& o, Value& v) { v = o.IsNotNull(); return true; } + +CTRL_PROPERTIES(EditInt, EditField) +PROPERTY("min", PropSetMin, PropGetMin) +PROPERTY("max", PropSetMax, PropGetMax) +PROPERTY("notnull", PropSetNotNull, PropGetNotNull) +END_CTRL_PROPERTIES + +//EditInt64 + +bool PropSetMin(EditInt64& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; } +bool PropGetMin(const EditInt64& o, Value& v) { v = o.GetMin(); return true; } +bool PropSetMax(EditInt64& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; } +bool PropGetMax(const EditInt64& o, Value& v) { v = o.GetMax(); return true; } +bool PropSetNotNull(EditInt64& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; } +bool PropGetNotNull(const EditInt64& o, Value& v) { v = o.IsNotNull(); return true; } + +CTRL_PROPERTIES(EditInt64, EditField) +PROPERTY("min", PropSetMin, PropGetMin) +PROPERTY("max", PropSetMax, PropGetMax) +PROPERTY("notnull", PropSetNotNull, PropGetNotNull) +END_CTRL_PROPERTIES + +//EditDouble + +bool PropSetMin(EditDouble& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; } +bool PropGetMin(const EditDouble& o, Value& v) { v = o.GetMin(); return true; } +bool PropSetMax(EditDouble& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; } +bool PropGetMax(const EditDouble& o, Value& v) { v = o.GetMax(); return true; } +bool PropSetNotNull(EditDouble& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; } +bool PropGetNotNull(const EditDouble& o, Value& v) { v = o.IsNotNull(); return true; } + +CTRL_PROPERTIES(EditDouble, EditField) +PROPERTY("min", PropSetMin, PropGetMin) +PROPERTY("max", PropSetMax, PropGetMax) +PROPERTY("notnull", PropSetNotNull, PropGetNotNull) +END_CTRL_PROPERTIES + +//NotNull variants + +CTRL_PROPERTIES(EditIntNotNull, EditInt) +END_CTRL_PROPERTIES + +CTRL_PROPERTIES(EditInt64NotNull, EditInt64) +END_CTRL_PROPERTIES + +CTRL_PROPERTIES(EditDoubleNotNull, EditDouble) +END_CTRL_PROPERTIES + +//EditIntSpin + +bool PropSetInc(EditIntSpin& o, const Value& v) { if(!IsNumber(v)) return false; o.SetInc(v); return true; } +bool PropGetInc(const EditIntSpin& o, Value& v) { v = o.GetInc(); return true; } +bool PropSetShowSpin(EditIntSpin& o, const Value& v) { if(!IsNumber(v)) return false; o.ShowSpin(v); return true; } +bool PropGetShowSpin(const EditIntSpin& o, Value& v) { v = o.IsShowSpin(); return true; } + +CTRL_PROPERTIES(EditIntSpin, EditInt) +PROPERTY("inc", PropSetInc, PropGetInc) +PROPERTY("showspin", PropSetShowSpin, PropGetShowSpin) +END_CTRL_PROPERTIES + +//EditInt64Spin + +bool PropSetInc(EditInt64Spin& o, const Value& v) { if(!IsNumber(v)) return false; o.SetInc(v); return true; } +bool PropGetInc(const EditInt64Spin& o, Value& v) { v = o.GetInc(); return true; } +bool PropSetShowSpin(EditInt64Spin& o, const Value& v) { if(!IsNumber(v)) return false; o.ShowSpin(v); return true; } +bool PropGetShowSpin(const EditInt64Spin& o, Value& v) { v = o.IsShowSpin(); return true; } + +CTRL_PROPERTIES(EditInt64Spin, EditInt64) +PROPERTY("inc", PropSetInc, PropGetInc) +PROPERTY("showspin", PropSetShowSpin, PropGetShowSpin) +END_CTRL_PROPERTIES + +//EditDoubleSpin + +bool PropSetInc(EditDoubleSpin& o, const Value& v) { if(!IsNumber(v)) return false; o.SetInc(v); return true; } +bool PropGetInc(const EditDoubleSpin& o, Value& v) { v = o.GetInc(); return true; } +bool PropSetShowSpin(EditDoubleSpin& o, const Value& v) { if(!IsNumber(v)) return false; o.ShowSpin(v); return true; } +bool PropGetShowSpin(const EditDoubleSpin& o, Value& v) { v = o.IsShowSpin(); return true; } + +CTRL_PROPERTIES(EditDoubleSpin, EditDouble) +PROPERTY("inc", PropSetInc, PropGetInc) +PROPERTY("showspin", PropSetShowSpin, PropGetShowSpin) +END_CTRL_PROPERTIES + +//NotNull variants + +CTRL_PROPERTIES(EditIntNotNullSpin, EditIntSpin) +END_CTRL_PROPERTIES + +CTRL_PROPERTIES(EditInt64NotNullSpin, EditInt64Spin) +END_CTRL_PROPERTIES + +CTRL_PROPERTIES(EditDoubleNotNullSpin, EditDoubleSpin) +END_CTRL_PROPERTIES + +//EditDate + +bool PropSetMin(EditDate& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; } +bool PropGetMin(const EditDate& o, Value& v) { v = o.GetMin(); return true; } +bool PropSetMax(EditDate& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; } +bool PropGetMax(const EditDate& o, Value& v) { v = o.GetMax(); return true; } +bool PropSetNotNull(EditDate& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; } +bool PropGetNotNull(const EditDate& o, Value& v) { v = o.IsNotNull(); return true; } + +CTRL_PROPERTIES(EditDate, EditField) +PROPERTY("min", PropSetMin, PropGetMin) +PROPERTY("max", PropSetMax, PropGetMax) +PROPERTY("notnull", PropSetNotNull, PropGetNotNull) +END_CTRL_PROPERTIES + +//EditTime + +bool PropSetMin(EditTime& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; } +bool PropGetMin(const EditTime& o, Value& v) { v = o.GetMin(); return true; } +bool PropSetMax(EditTime& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; } +bool PropGetMax(const EditTime& o, Value& v) { v = o.GetMax(); return true; } +bool PropSetNotNull(EditTime& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; } +bool PropGetNotNull(const EditTime& o, Value& v) { v = o.IsNotNull(); return true; } +bool PropSetSeconds(EditTime& o, const Value& v) { if(!IsNumber(v)) return false; o.Seconds(v); return true; } +bool PropGetSeconds(const EditTime& o, Value& v) { v = o.IsSeconds(); return true; } + +CTRL_PROPERTIES(EditTime, EditField) +PROPERTY("min", PropSetMin, PropGetMin) +PROPERTY("max", PropSetMax, PropGetMax) +PROPERTY("notnull", PropSetNotNull, PropGetNotNull) +PROPERTY("seconds", PropSetSeconds, PropGetSeconds) +END_CTRL_PROPERTIES + +//NotNull variants + +CTRL_PROPERTIES(EditDateNotNull, EditDate) +END_CTRL_PROPERTIES + +CTRL_PROPERTIES(EditTimeNotNull, EditTime) +END_CTRL_PROPERTIES diff --git a/bazaar/CtrlProp/PushCtrl.cpp b/bazaar/CtrlProp/PushCtrl.cpp new file mode 100644 index 000000000..b7c8e3443 --- /dev/null +++ b/bazaar/CtrlProp/PushCtrl.cpp @@ -0,0 +1,52 @@ +#include "CtrlProp.h" +#include + +bool PropSetLabel(Pusher& o, const Value& v) { if(!IsString(v)) return false; o.SetLabel(String(v)); return true; } +bool PropGetLabel(const Pusher& o, Value& v) { v = o.GetLabel(); return true; } +bool PropSetClickFocus(Pusher& o, const Value& v) { if(!IsNumber(v)) return false; o.ClickFocus(v); return true; } +bool PropGetClickFocus(const Pusher& o, Value& v) { v = o.IsClickFocus(); return true; } +bool PropGetVisualState(const Pusher& o, Value& v) { v = o.GetVisualState(); return true; } + +CTRL_PROPERTIES(Pusher, Ctrl) +PROPERTY("label", PropSetLabel, PropGetLabel) +PROPERTY("clickfocus", PropSetClickFocus, PropGetClickFocus) +//PROPERTY_GET("visualstate", PropGetVisualState) +END_CTRL_PROPERTIES + +CTRL_PROPERTIES(Button, Pusher) +END_CTRL_PROPERTIES + +bool PropSetLabel(ButtonOption& o, const Value& v) { if(!IsString(v)) return false; o.SetLabel(v); return true; } +bool PropGetLabel(const ButtonOption& o, Value& v) { v = o.GetLabel(); return true; } + +CTRL_PROPERTIES(ButtonOption, Ctrl) +PROPERTY("label", PropSetLabel, PropGetLabel) +END_CTRL_PROPERTIES + +bool PropSetBlackEdge(Option& o, const Value& v) { if(!IsNumber(v)) return false; o.BlackEdge(v); return true; } +bool PropGetBlackEdge(const Option& o, Value& v) { v = o.IsBlackEdge(); return true; } +bool PropSetSwitchImage(Option& o, const Value& v) { if(!IsNumber(v)) return false; o.SwitchImage(v); return true; } +bool PropGetSwitchImage(const Option& o, Value& v) { v = o.IsSwitchImage(); return true; } +bool PropSetThreeState(Option& o, const Value& v) { if(!IsNumber(v)) return false; o.ThreeState(v); return true; } +bool PropGetThreeState(const Option& o, Value& v) { v = o.IsThreeState(); return true; } +bool PropSetShowLabel(Option& o, const Value& v) { if(!IsNumber(v)) return false; o.ShowLabel(v); return true; } +bool PropGetShowLabel(const Option& o, Value& v) { v = o.IsShowLabel(); return true; } +bool PropSetNotNull(Option& o, const Value& v) { if(!IsNumber(v)) return false; o.NotNull(v); return true; } +bool PropGetNotNull(const Option& o, Value& v) { v = o.IsNotNull(); return true; } + +CTRL_PROPERTIES(Option, Pusher) +PROPERTY("blackedge", PropSetBlackEdge, PropGetBlackEdge) +PROPERTY("switchimage", PropSetSwitchImage, PropGetSwitchImage) +PROPERTY("threestate", PropSetThreeState, PropGetThreeState) +PROPERTY("showlabel", PropSetShowLabel, PropGetShowLabel) +PROPERTY("notnull", PropSetNotNull, PropGetNotNull) +END_CTRL_PROPERTIES + +bool PropSetLabel(Switch& o, const Value& v) { o.SetLabel(AsString(v)); return true; } +bool PropGetLabel(const Switch& o, Value& v) { v = o.GetLabel(); return true; } + +CTRL_PROPERTIES(Switch, Ctrl) +PROPERTY("label", PropSetLabel, PropGetLabel) +END_CTRL_PROPERTIES + + diff --git a/bazaar/CtrlProp/SliderCtrl.cpp b/bazaar/CtrlProp/SliderCtrl.cpp new file mode 100644 index 000000000..a36d2851d --- /dev/null +++ b/bazaar/CtrlProp/SliderCtrl.cpp @@ -0,0 +1,18 @@ +#include "CtrlProp.h" +#include + +//SliderCtrl + +bool PropSetMin(SliderCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(v, o.GetMax()); return true; } +bool PropGetMin(const SliderCtrl& o, Value& v) { v = o.GetMin(); return true; } +bool PropSetMax(SliderCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.MinMax(o.GetMin(), v); return true; } +bool PropGetMax(const SliderCtrl& o, Value& v) { v = o.GetMax(); return true; } +bool PropSetStep(SliderCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.Step(v); return true; } +bool PropGetStep(const SliderCtrl& o, Value& v) { v = o.GetStep(); return true; } + +CTRL_PROPERTIES(SliderCtrl, Ctrl) +PROPERTY("min", PropSetMin, PropGetMin) +PROPERTY("max", PropSetMax, PropGetMax) +PROPERTY("step", PropSetStep, PropGetStep) +END_CTRL_PROPERTIES + diff --git a/bazaar/CtrlProp/StaticCtrl.cpp b/bazaar/CtrlProp/StaticCtrl.cpp new file mode 100644 index 000000000..b965adf52 --- /dev/null +++ b/bazaar/CtrlProp/StaticCtrl.cpp @@ -0,0 +1,65 @@ +#include "CtrlProp.h" +#include + +//StaticText + +bool PropSetInk(StaticText& o, const Value& v) { if(!v.Is()) return false; o.SetInk(v); return true; } +bool PropGetInk(const StaticText& o, Value& v) { v = o.GetInk(); return true; } +bool PropSetText(StaticText& o, const Value& v) { o.SetText(AsString(v)); return true; } +bool PropGetText(const StaticText& o, Value& v) { v = o.GetText(); return true; } +bool PropSetAlign(StaticText& o, const Value& v) { if(!IsNumber(v)) return false; o.SetAlign(v); return true; } +bool PropGetAlign(const StaticText& o, Value& v) { v = o.GetAlign(); return true; } + +CTRL_PROPERTIES(StaticText, Ctrl) +PROPERTY("ink", PropSetInk, PropGetInk) +PROPERTY("text", PropSetText, PropGetText) +PROPERTY("align", PropSetAlign, PropGetAlign) +END_CTRL_PROPERTIES + +//Label + +bool PropSetText(Label& o, const Value& v) { o.SetText(AsString(v)); return true; } +bool PropGetText(const Label& o, Value& v) { v = o.GetText(); return true; } + +CTRL_PROPERTIES(Label, StaticText) +PROPERTY("text", PropSetText, PropGetText) +END_CTRL_PROPERTIES + +//LabelBox + +CTRL_PROPERTIES(LabelBox, Label) +END_CTRL_PROPERTIES + +//ParentCtrl + +CTRL_PROPERTIES(ParentCtrl, Ctrl) +END_CTRL_PROPERTIES + +//StaticRect + +bool PropSetBackground(StaticRect& o, const Value& v) { if(!v.Is()) return false; o.Background(v); return true; } +bool PropGetBackground(const StaticRect& o, Value& v) { v = o.GetBackground(); return true; } + +CTRL_PROPERTIES(StaticRect, Ctrl) +PROPERTY("background", PropSetBackground, PropGetBackground) +END_CTRL_PROPERTIES + +//ImageCtrl + +CTRL_PROPERTIES(ImageCtrl, Ctrl) +END_CTRL_PROPERTIES + +//DisplayCtrl + +CTRL_PROPERTIES(DisplayCtrl, Ctrl) +END_CTRL_PROPERTIES + +//Picture + +CTRL_PROPERTIES(Picture, Ctrl) +END_CTRL_PROPERTIES + +//SeparatorCtrl + +CTRL_PROPERTIES(SeparatorCtrl, Ctrl) +END_CTRL_PROPERTIES diff --git a/bazaar/CtrlProp/TextEdit.cpp b/bazaar/CtrlProp/TextEdit.cpp new file mode 100644 index 000000000..c5ba3e644 --- /dev/null +++ b/bazaar/CtrlProp/TextEdit.cpp @@ -0,0 +1,53 @@ +#include "CtrlProp.h" +#include + +//TextCtrl + +bool PropSetUndoSteps(TextCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.UndoSteps(v); return true; } +bool PropGetUndoSteps(const TextCtrl& o, Value& v) { v = o.GetUndoSteps(); return true; } +bool PropSetProcessTab(TextCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.ProcessTab(v); return true; } +bool PropGetProcessTab(const TextCtrl& o, Value& v) { v = o.IsProcessTab(); return true; } +bool PropSetProcessEnter(TextCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.ProcessEnter(v); return true; } +bool PropGetProcessEnter(const TextCtrl& o, Value& v) { v = o.IsProcessEnter(); return true; } +bool PropSetNoBackground(TextCtrl& o, const Value& v) { if(!IsNumber(v)) return false; o.NoBackground(v); return true; } +bool PropGetNoBackground(const TextCtrl& o, Value& v) { v = o.IsNoBackground(); return true; } + +CTRL_PROPERTIES(TextCtrl, Ctrl) +PROPERTY("undosteps", PropSetUndoSteps, PropGetUndoSteps) +PROPERTY("processtab", PropSetProcessTab, PropGetProcessTab) +PROPERTY("processenter", PropSetProcessEnter, PropGetProcessEnter) +PROPERTY("nobackground", PropSetNoBackground, PropGetNoBackground) +END_CTRL_PROPERTIES + +//LineEdit + +bool PropSetTabSize(LineEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.TabSize(v); return true; } +bool PropGetTabSize(const LineEdit& o, Value& v) { v = o.GetTabSize(); return true; } +bool PropSetShowTabs(LineEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.ShowTabs(v); return true; } +bool PropGetShowTabs(const LineEdit& o, Value& v) { v = o.IsShowTabs(); return true; } +bool PropSetCutLine(LineEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.WithCutLine(v); return true; } +bool PropGetCutLine(const LineEdit& o, Value& v) { v = o.IsWithCutLine(); return true; } +bool PropSetNoHorzScrollbar(LineEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.NoHorzScrollbar(v); return true; } +bool PropGetNoHorzScrollbar(const LineEdit& o, Value& v) { v = o.IsNoHorzScrollbar(); return true; } + +CTRL_PROPERTIES(LineEdit, TextCtrl) +PROPERTY("tabsize", PropSetTabSize, PropGetTabSize) +PROPERTY("showtabs", PropSetShowTabs, PropGetShowTabs) +PROPERTY("cutline", PropSetCutLine, PropGetCutLine) +PROPERTY("nohorzsb", PropSetNoHorzScrollbar, PropGetNoHorzScrollbar) +END_CTRL_PROPERTIES + +//DocEdit + +bool PropSetAutoHideSb(DocEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.AutoHideSb(v); return true; } +bool PropGetAutoHideSb(const DocEdit& o, Value& v) { v = o.IsAutoHideSb(); return true; } +bool PropSetUpDownLeave(DocEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.UpDownLeave(v); return true; } +bool PropGetUpDownLeave(const DocEdit& o, Value& v) { v = o.IsUpDownLeave(); return true; } +bool PropSetEofLine(DocEdit& o, const Value& v) { if(!IsNumber(v)) return false; o.EofLine(v); return true; } +bool PropGetEofLine(const DocEdit& o, Value& v) { v = o.IsEofLine(); return true; } + +CTRL_PROPERTIES(DocEdit, TextCtrl) +PROPERTY("autohidesb", PropSetAutoHideSb, PropGetAutoHideSb) +PROPERTY("updownleave", PropSetUpDownLeave, PropGetUpDownLeave) +PROPERTY("eofline", PropSetEofLine, PropGetEofLine) +END_CTRL_PROPERTIES diff --git a/bazaar/CtrlProp/init b/bazaar/CtrlProp/init new file mode 100644 index 000000000..ea2db2173 --- /dev/null +++ b/bazaar/CtrlProp/init @@ -0,0 +1,6 @@ +#ifndef _CtrlProp_icpp_init_stub +#define _CtrlProp_icpp_init_stub +#include "CtrlLib/init" +#include "LogPosCtrl/init" +#include "ValueCtrl/init" +#endif diff --git a/bazaar/CtrlPropTest/CtrlPropTest.h b/bazaar/CtrlPropTest/CtrlPropTest.h new file mode 100644 index 000000000..eed320742 --- /dev/null +++ b/bazaar/CtrlPropTest/CtrlPropTest.h @@ -0,0 +1,50 @@ +#ifndef _CtrlPropTest_CtrlPropTest_h +#define _CtrlPropTest_CtrlPropTest_h + +#include + +using namespace Upp; + +#define LAYOUTFILE +#include + +#include +#include +#include + +bool MyMouseHook(Ctrl *ctrl, bool inframe, int event, Point p, + int zdelta, dword keyflags); +void DoList(Ctrl& c); +void DoEdit(Ctrl& c); +bool CanEdit(); + +class CtrlPropTest : public WithCtrlPropTestLayout { +public: + typedef CtrlPropTest CLASSNAME; + CtrlPropTest(); + + //hook + void EditCB(); + + void OnCtrlLeft(Ctrl& c, Point p, dword keyflags); + void OnCtrlRight(Ctrl& c, Point p, dword keyflags); + void OnRectChange(); + void OnMissed(Point p, dword keyflags); + + //misc + void Test(); + void InitDummies(); + +public: + ToolBar mb; + ToolBar::Item * mbi; + CtrlFinder hk; + RectCtrl rc; + RectCtrl::Style rcst; + Ptr ctrl; + + Array arc; +}; + +#endif + diff --git a/bazaar/CtrlPropTest/CtrlPropTest.lay b/bazaar/CtrlPropTest/CtrlPropTest.lay new file mode 100644 index 000000000..565100dc6 --- /dev/null +++ b/bazaar/CtrlPropTest/CtrlPropTest.lay @@ -0,0 +1,45 @@ +LAYOUT(CtrlPropTestLayout, 768, 472) + ITEM(DocEdit, de, Tip(t_("DocEdit")).LeftPosZ(0, 152).TopPosZ(0, 44)) + ITEM(LineEdit, le, Tip(t_("LineEdit")).LeftPosZ(0, 152).TopPosZ(48, 19)) + ITEM(EditField, ef, Tip(t_("EditField")).LeftPosZ(0, 152).TopPosZ(72, 19)) + ITEM(EditString, es, Tip(t_("EditString")).LeftPosZ(0, 152).TopPosZ(96, 19)) + ITEM(Button, b, SetLabel(t_("Button")).Tip(t_("Button")).LeftPosZ(156, 56).TopPosZ(0, 20)) + ITEM(Option, o, SetLabel(t_("Option")).Tip(t_("Option")).LeftPosZ(156, 56).TopPosZ(24, 16)) + ITEM(Switch, sw, SetLabel(t_("Switch\nother")).LeftPosZ(156, 56).TopPosZ(48, 44)) + ITEM(ButtonOption, bo, LeftPosZ(156, 56).TopPosZ(96, 20)) + ITEM(DataPusher, dp, Tip(t_("DataPusher")).LeftPosZ(216, 92).TopPosZ(0, 20)) + ITEM(SliderCtrl, sl, LeftPosZ(216, 92).TopPosZ(24, 20)) + ITEM(Label, l, SetLabel(t_("Label")).LeftPosZ(312, 64).TopPosZ(0, 19)) + ITEM(LabelBox, lb, SetLabel(t_("LabelBox")).LeftPosZ(312, 64).TopPosZ(24, 92)) + ITEM(StaticText, st, SetText(t_("StaticText")).LeftPosZ(216, 92).TopPosZ(96, 19)) + ITEM(RichTextCtrl, rtc, LeftPosZ(216, 92).TopPosZ(48, 19)) + ITEM(EditInt, ei, Tip(t_("EditInt")).LeftPosZ(0, 76).TopPosZ(124, 19)) + ITEM(EditInt64, ei64, Tip(t_("EditInt64")).LeftPosZ(0, 76).TopPosZ(144, 19)) + ITEM(EditDouble, ed, Tip(t_("EditDouble")).LeftPosZ(0, 76).TopPosZ(164, 19)) + ITEM(EditIntNotNull, einn, Tip(t_("EditIntNotNull")).LeftPosZ(76, 76).TopPosZ(124, 19)) + ITEM(EditInt64NotNull, ei64nn, LeftPosZ(76, 76).TopPosZ(144, 19)) + ITEM(EditDoubleNotNull, ednn, Tip(t_("EditDoubleNotNull")).LeftPosZ(76, 76).TopPosZ(164, 19)) + ITEM(EditIntSpin, eis, Tip(t_("EditIntSpin")).LeftPosZ(156, 76).TopPosZ(124, 19)) + ITEM(EditInt64Spin, ei64s, LeftPosZ(156, 76).TopPosZ(144, 19)) + ITEM(EditDoubleSpin, eds, Tip(t_("EditDoubleSpin")).LeftPosZ(156, 76).TopPosZ(164, 19)) + ITEM(EditIntNotNullSpin, einns, LeftPosZ(236, 76).TopPosZ(124, 19)) + ITEM(EditInt64NotNullSpin, ei64nns, LeftPosZ(236, 76).TopPosZ(144, 19)) + ITEM(EditDoubleNotNullSpin, ednns, LeftPosZ(236, 76).TopPosZ(164, 19)) + ITEM(EditDate, edt, Tip(t_("EditDate")).LeftPosZ(0, 76).TopPosZ(192, 19)) + ITEM(EditTime, etm, Tip(t_("EditTime")).LeftPosZ(0, 76).TopPosZ(212, 19)) + ITEM(EditDateNotNull, edtnn, LeftPosZ(76, 76).TopPosZ(192, 19)) + ITEM(EditTimeNotNull, etmnn, LeftPosZ(76, 76).TopPosZ(212, 19)) + ITEM(ProgressIndicator, pi, LeftPosZ(264, 112).TopPosZ(192, 20)) + ITEM(Progress, pr, LeftPosZ(276, 100).TopPosZ(212, 20)) + ITEM(DropDate, ddt, LeftPosZ(156, 104).TopPosZ(192, 19)) + ITEM(DropTime, dtm, LeftPosZ(156, 120).TopPosZ(212, 19)) + ITEM(DropList, dl, LeftPosZ(0, 220).TopPosZ(344, 19)) + ITEM(ArrayCtrl, ac, LeftPosZ(0, 220).TopPosZ(236, 104)) + ITEM(RichTextView, rtv, LeftPosZ(216, 92).TopPosZ(72, 19)) + ITEM(TabCtrl, tb, LeftPosZ(224, 220).TopPosZ(236, 104)) + ITEM(Clock, clk, LeftPosZ(380, 150).TopPosZ(0, 156)) + ITEM(Calendar, cl, LeftPosZ(532, 236).TopPosZ(0, 156)) + ITEM(DropTree, dtr, LeftPosZ(224, 220).TopPosZ(344, 19)) + ITEM(TreeCtrl, tr, LeftPosZ(448, 160).TopPosZ(160, 204)) +END_LAYOUT + diff --git a/bazaar/CtrlPropTest/CtrlPropTest.upp b/bazaar/CtrlPropTest/CtrlPropTest.upp new file mode 100644 index 000000000..cdbc8c6b4 --- /dev/null +++ b/bazaar/CtrlPropTest/CtrlPropTest.upp @@ -0,0 +1,20 @@ +description "Ctrl Properties editor, grabber, resizer..\377"; + +uses + CtrlLib, + CtrlProp, + CtrlFinder, + RectCtrl; + +file + CtrlPropTest.h, + main.cpp, + edit.cpp, + find.cpp, + hook.cpp, + misc.cpp, + CtrlPropTest.lay; + +mainconfig + "" = "GUI MT"; + diff --git a/bazaar/CtrlPropTest/edit.cpp b/bazaar/CtrlPropTest/edit.cpp new file mode 100644 index 000000000..baa0a004c --- /dev/null +++ b/bazaar/CtrlPropTest/edit.cpp @@ -0,0 +1,40 @@ +#include "CtrlPropTest.h" + +void DoEdit(Ctrl& c) +{ + PropEdit& pe = Single(); + if(pe.IsOpen()) return; + + Ctrl* owner = Ctrl::GetActiveWindow(); + if(!owner) + { + Exclamation("No Active Window"); + return; + } + + pe.Rejector(); pe.PopUp(owner, c); +} + +void DoList(Ctrl& c) +{ + PropList& pe = Single(); + if(pe.IsOpen()) return; + + Ctrl* owner = Ctrl::GetActiveWindow(); + if(!owner) + { + Exclamation("No Active Window"); + return; + } + + pe.Rejector(); pe.PopUp(owner, c); +} + +bool CanEdit() +{ + PropEdit& pe = Single(); + if(pe.IsOpen()) return false; + PropList& pl = Single(); + if(pl.IsOpen()) return false; + return true; +} diff --git a/bazaar/CtrlPropTest/find.cpp b/bazaar/CtrlPropTest/find.cpp new file mode 100644 index 000000000..53e8f2f95 --- /dev/null +++ b/bazaar/CtrlPropTest/find.cpp @@ -0,0 +1,34 @@ +#include "CtrlPropTest.h" + +void CtrlPropTest::OnCtrlLeft(Ctrl& c, Point p, dword keyflags) +{ + if(&c == &rc) return; + if(&c == &hk) return; + if(!CanEdit()) return; + rc.SetData(c.GetRect()); + Add(rc.SizePos()); + ctrl = &c; +} + +void CtrlPropTest::OnCtrlRight(Ctrl& c, Point p, dword keyflags) +{ + if(&c == &rc) return; + if(&c == &hk) return; + if(!CanEdit()) return; + if(keyflags == K_SHIFT) + DoList(c); + else + DoEdit(c); +} + +void CtrlPropTest::OnRectChange() +{ + if(!ctrl) return; + ctrl->SetRect(rc.GetData()); +} + +void CtrlPropTest::OnMissed(Point p, dword keyflags) +{ + rc.Remove(); //leave move + hk.LeftDown(p, keyflags); +} diff --git a/bazaar/CtrlPropTest/hook.cpp b/bazaar/CtrlPropTest/hook.cpp new file mode 100644 index 000000000..78ca999a7 --- /dev/null +++ b/bazaar/CtrlPropTest/hook.cpp @@ -0,0 +1,26 @@ +#include "CtrlPropTest.h" + +bool MyMouseHook(Ctrl *ctrl, bool inframe, int event, Point p, + int zdelta, dword keyflags) +{ + if(event & (Ctrl::MOUSEMOVE | Ctrl::MOUSEENTER | Ctrl::MOUSELEAVE | Ctrl::CURSORIMAGE)) return false; + if((keyflags & K_MOUSERIGHT)) + if((keyflags & K_SHIFT_CTRL)) + { + if(!CanEdit()) return false; + + CallbackArgTarget m; + MenuBar menu; + menu.Add("List Properties",m[0]); + menu.Add("Edit Properties",m[1]); + menu.Execute(); + if(IsNull(m)) return true; + switch(m) + { + case 0: DoList(*ctrl); break; + case 1: DoEdit(*ctrl); break; + } + return true; + } + return false; +} diff --git a/bazaar/CtrlPropTest/init b/bazaar/CtrlPropTest/init new file mode 100644 index 000000000..5eaded6df --- /dev/null +++ b/bazaar/CtrlPropTest/init @@ -0,0 +1,7 @@ +#ifndef _CtrlPropTest_icpp_init_stub +#define _CtrlPropTest_icpp_init_stub +#include "CtrlLib/init" +#include "CtrlProp/init" +#include "CtrlFinder/init" +#include "RectCtrl/init" +#endif diff --git a/bazaar/CtrlPropTest/main.cpp b/bazaar/CtrlPropTest/main.cpp new file mode 100644 index 000000000..11971c52c --- /dev/null +++ b/bazaar/CtrlPropTest/main.cpp @@ -0,0 +1,46 @@ +#include "CtrlPropTest.h" + +void CtrlPropTest::EditCB() +{ + if(hk.IsEnabled()) + { + hk.Disable(); + mbi->Check(false); + } + else + { + SetFocus(); //kill foucus from all others + hk.Enable(); + rc.Remove(); + mbi->Check(true); + } +} + +CtrlPropTest::CtrlPropTest() +{ + CtrlLayout(*this, "Window title"); + + mbi = &mb.Add(!IsReadOnly(), t_("Edit"), CtrlImg::selection(), + THISBACK(EditCB)); + AddFrame(mb); + + InstallMouseHook(&MyMouseHook); + + hk.WhenLeftDown = THISBACK(OnCtrlLeft); + hk.WhenRightDown = THISBACK(OnCtrlRight); + hk.Disable(); + Add(hk.SizePos()); + + rcst = RectCtrl::StyleDefault(); + rcst.rectcol = Null; + rc.SetStyle(rcst); + rc <<= THISBACK(OnRectChange); + rc.WhenMissed = THISBACK(OnMissed); + + InitDummies(); +} + +GUI_APP_MAIN +{ + CtrlPropTest().Run(); +} diff --git a/bazaar/CtrlPropTest/misc.cpp b/bazaar/CtrlPropTest/misc.cpp new file mode 100644 index 000000000..f404825da --- /dev/null +++ b/bazaar/CtrlPropTest/misc.cpp @@ -0,0 +1,123 @@ +#include "CtrlPropTest.h" + +void CtrlPropTest::InitDummies() +{ + bo.SetLabel("MyCtrlsImg"); + + de.SetData("This is a\nDocEdit example text"); + le.SetData("LineEdit"); + ef.SetData("EditField"); + es.SetData("EditString"); + + ei = 100; + ei64 = 22342599399929; + ed = 10.3; + + einn <<= 100; + ei64nn <<= 22342599399929; + ednn <<= 10.3; + + eis <<= 100; + ei64s <<= 22342599399929; + eds <<= 10.3; + + einns <<= 100; + ei64nns <<= 22342599399929; + ednns <<= 10.3; + + edt <<= GetSysDate(); + etm <<= GetSysTime(); + + edtnn <<= GetSysDate(); + etmnn <<= GetSysTime(); + + ddt <<= GetSysDate(); + dtm <<= GetSysTime(); + + ac.AddColumn("One"); + ac.AddColumn("Two"); + ac.Add("Hello", 1234); + ac.Add(23.8, "servus"); + ac.Add("foo", true); + ac.Add("bar", "lee"); + + sl <<= 0; + + dl.Add(0,"First"); + dl.Add(1,"Second"); + dl.Add(2,"Third"); + dl.Add(3,"Fourth"); + + + Vector parent, parent2; + parent.Add(0); + tr.SetRoot(Image(), "The Tree"); + for(int i = 1; i < 10000; i++) { + parent.Add(tr.Add(parent[rand() % parent.GetCount()], Image(), + FormatIntRoman(i, true))); + if((rand() & 3) == 0) + tr.Open(parent.Top()); + } + tr.Open(0); + + { + TreeCtrl& tree = dtr->MultiSelect(); + Vector parent, parent2; + parent.Add(0); + tree.SetRoot(Image(), "The Tree"); + for(int i = 1; i < 10000; i++) { + parent.Add(tree.Add(parent[rand() % parent.GetCount()], Image(), + FormatIntRoman(i, true))); + if((rand() & 3) == 0) + tree.Open(parent.Top()); + } + tree.Open(0); + } + + tb.Add(arc.Add(new EditInt()).SizePos(),"First"); + tb.Add(arc.Add(new EditInt()).SizePos(),"Second"); + tb.Add(arc.Add(new EditInt()).SizePos(),"Third"); +} + +void CtrlPropTest::Test() +{ + EditInt ei; + bool b; + + ei.Tip("Tooltip for this one"); + + b = SetProperty(ei, "data", 10); + RLOG(b); + + Value v; + b = GetProperty(ei, "data", v); + RLOG(b << v); + + b = SetProperty(ei, "min", -100); + RLOG(b); + b = SetProperty(ei, "max", 100); + RLOG(b); + + b = GetProperty(ei, "min", v); + RLOG(b << v); + b = GetProperty(ei, "max", v); + RLOG(b << v); + + v = Value(); + b = GetProperty(ei, "listset", v); + RLOG(b << v); + + v = Value(); + b = GetProperty(ei, "listget", v); + RLOG(b << v); + + ValueArray va = v; + for(int i = 0; i < va.GetCount(); i++) + { + String s = va.Get(i); + RLOG(s); + v = Value(); + b = GetProperty(ei, s, v); + RLOG(v << "\n"); + } +} diff --git a/bazaar/Iter/Iter.cpp b/bazaar/Iter/Iter.cpp new file mode 100644 index 000000000..8883343a6 --- /dev/null +++ b/bazaar/Iter/Iter.cpp @@ -0,0 +1 @@ +#include "Iter.h" diff --git a/bazaar/Iter/Iter.h b/bazaar/Iter/Iter.h new file mode 100644 index 000000000..f942ef720 --- /dev/null +++ b/bazaar/Iter/Iter.h @@ -0,0 +1,323 @@ +#ifndef _Iter_Iter_h +#define _Iter_Iter_h + +#include +using namespace Upp; + +#include + +template +class ConstIter : public Copyable > +{ +public: + virtual void Reset() = 0; + virtual const T& Get() const = 0; + virtual bool Next() = 0; + + const T& operator*() { return Get(); } + const T *operator->() { return &Get(); } + + ConstIter& operator++() { Next(); return *this; } + //cant use postfix because need to 'clone' the iter from base class + //and this can only happen on heap, cant return on stack + //ConstIter operator++(int) { ConstIter t = *this; ++ii; return t; } +}; + +template +class Iter : public Copyable > +{ +public: + virtual void Reset() = 0; + virtual T& Get() const = 0; + virtual bool Next() = 0; + + T& operator*() { return Get(); } + T *operator->() { return &Get(); } + + Iter& operator++() { Next(); return *this; } + //cant use postfix because need to 'clone' the iter from base class + //and this can only happen on heap, cant return on stack + //Iter operator++(int) { Iter t = *this; ++ii; return t; } +}; + +template +class ConstIterCont : public ConstIter +{ + friend class IterCreator; +protected: + const V* cont; + int ii; + +public: + virtual void Reset() { ii = -1; } + virtual const T& Get() const { return (*cont)[ii]; } + virtual bool Next() { return (++ii < cont->GetCount()); } + + virtual ConstIterCont* Copy() const { return new ConstIterCont(*this); } + virtual ConstIterCont* PartialCopy() const { ConstIterCont* t = Copy(); t->Reset(); return t; } + + ConstIterCont() : cont(NULL), ii(-1) {} + ConstIterCont(const V& _cont) : cont(&_cont), ii(-1) {} + ConstIterCont(const V& _cont, int ii) : cont(&_cont), ii(ii) {} +}; + +template +class IterCont : public Iter +{ + friend class IterCreator; +protected: + V* cont; + int ii; + +public: + virtual void Reset() { ii = -1; } + virtual T& Get() const { return (*cont)[ii]; } + virtual bool Next() { return (++ii < cont->GetCount()); } + + virtual IterCont* Copy() const { return new IterCont(*this); } + virtual IterCont* PartialCopy() const { IterCont* t = Copy(); t->Reset(); return t; } + + IterCont() : cont(NULL), ii(-1) {} + IterCont(V& _cont) : cont(&_cont), ii(-1) {} + IterCont(V& _cont, int ii) : cont(&_cont), ii(ii) {} +}; + +#define ITER_CONT(Cont) \ + template inline static Iter* GetIter(Cont& cont) { return new IterCont(cont); } \ + template inline static Iter* GetIter(Cont& cont, int ii) { return new IterCont(cont, ii); } \ + template inline static ConstIter* GetIter(const Cont& cont) { return new ConstIterCont(cont); } \ + template inline static ConstIter* GetIter(const Cont& cont, int ii) { return new ConstIterCont(cont, ii); } \ + + +template +class ConstIterPtr : public ConstIter +{ + friend class IterCreator; +protected: + const V* cont; + int ii; + +public: + virtual void Reset() { ii = -1; } + virtual const T& Get() const { ASSERT(ii==0); return *(*cont); } + virtual bool Next() { return (++ii < 1); } + + virtual ConstIterPtr* Copy() const { return new ConstIterPtr(*this); } + virtual ConstIterPtr* PartialCopy() const { ConstIterPtr* t = Copy(); t->Reset(); return t; } + + ConstIterPtr() : cont(NULL), ii(-1) {} + ConstIterPtr(const V& _cont) : cont(&_cont), ii(-1) {} + ConstIterPtr(const V& _cont, int ii) : cont(&_cont), ii(ii) {} +}; + +template +class IterPtr : public Iter +{ + friend class IterCreator; +protected: + V* cont; + int ii; + +public: + virtual void Reset() { ii = -1; } + virtual T& Get() const { ASSERT(ii==0); return *(*cont); } + virtual bool Next() { return (++ii < 1); } + + virtual IterPtr* Copy() const { return new IterPtr(*this); } + virtual IterPtr* PartialCopy() const { IterPtr* t = Copy(); t->Reset(); return t; } + + IterPtr() : cont(NULL), ii(-1) {} + IterPtr(V& _cont) : cont(&_cont), ii(-1) {} + IterPtr(V& _cont, int ii) : cont(&_cont), ii(ii) {} +}; + +#define ITER_PTR(Cont) \ + template inline static Iter* GetIter(Cont& cont) { return new IterPtr(cont); } \ + template inline static ConstIter* GetIter(const Cont& cont) { return new ConstIterPtr(cont); } \ + + +template +class ConstIterAny : public ConstIter +{ + friend class IterCreator; +protected: + const Any* cont; + int ii; + +public: + virtual void Reset() { ii = -1; } + virtual const T& Get() const { ASSERT(ii==0); ASSERT(cont->Is()); return cont->Get(); } + virtual bool Next() { return (++ii < 1); } + + virtual ConstIterAny* Copy() const { return new ConstIterAny(*this); } + virtual ConstIterAny* PartialCopy() const { ConstIterAny* t = Copy(); t->Reset(); return t; } + + ConstIterAny() : cont(NULL), ii(-1) {} + ConstIterAny(const Any& _cont) : cont(&_cont), ii(-1) {} + ConstIterAny(const Any& _cont, int ii) : cont(&_cont), ii(ii) {} +}; + +template +class IterAny : public Iter +{ + friend class IterCreator; +protected: + Any *cont; + int ii; + +public: + virtual void Reset() { ii = -1; } + virtual T& Get() const { ASSERT(ii==0); ASSERT(cont->Is()); return cont->Get(); } + virtual bool Next() { return (++ii < 1); } + + virtual IterAny* Copy() const { return new IterAny(*this); } + virtual IterAny* PartialCopy() const { IterAny* t = Copy(); t->Reset(); return t; } + + IterAny() : cont(NULL), ii(-1) {} + IterAny(Any& _cont) : cont(&_cont), ii(-1) {} + IterAny(Any& _cont, int ii) : cont(&_cont), ii(ii) {} +}; + +template +class ConstIterValue : public ConstIter +{ + friend class IterCreator; +protected: + const Value* cont; + int ii; + +public: + virtual void Reset() { ii = -1; } + virtual const T& Get() const { ASSERT(ii==0); ASSERT(cont->Is()); return ValueTo(*cont); } + virtual bool Next() { return (++ii < 1); } + + virtual ConstIterValue* Copy() const { return new ConstIterValue(*this); } + virtual ConstIterValue* PartialCopy() const { ConstIterValue* t = Copy(); t->Reset(); return t; } + + ConstIterValue() : cont(NULL), ii(-1) {} + ConstIterValue(const Value& _cont) : cont(&_cont), ii(-1) {} + ConstIterValue(const Value& _cont, int ii) : cont(&_cont), ii(ii) {} +}; + +template +class IterValue : public Iter +{ + friend class IterCreator; +protected: + Value* cont; + int ii; + +public: + virtual void Reset() { ii = -1; } + virtual T& Get() const { ASSERT(ii==0); ASSERT(cont->Is()); return const_cast(ValueTo(*cont)); } + virtual bool Next() { return (++ii < 1); } + + virtual IterValue* Copy() const { return new IterValue(*this); } + virtual IterValue* PartialCopy() const { IterValue* t = Copy(); t->Reset(); return t; } + + IterValue() : cont(NULL), ii(-1) {} + IterValue(Value& _cont) : cont(&_cont), ii(-1) {} + IterValue(Value& _cont, int ii) : cont(&_cont), ii(ii) {} +}; + +template +class ConstIterLink : public ConstIter +{ + friend class IterCreator; +protected: + const Link* cont; + const Link* start; + int ii; + +public: + virtual void Reset() { ii = -1; cont = start; } + virtual const T& Get() const { ASSERT(ii>=0); return *cont->GetPtr(); } + virtual bool Next() { ++ii; return ((cont = cont->GetNext()) != start); } + + virtual ConstIterLink* Copy() const { return new ConstIterLink(*this); } + virtual ConstIterLink* PartialCopy() const { ConstIterLink* t = Copy(); t->Reset(); return t; } + + ConstIterLink() : cont(NULL), ii(-1) {} + ConstIterLink(const Link& _cont) : cont(&_cont), start(&_cont), ii(-1) {} + ConstIterLink(const Link& _cont, int ii) : cont(&_cont), start(&_cont), ii(ii) {} +}; + +template +class IterLink : public Iter +{ + friend class IterCreator; +protected: + Link* cont; + Link* start; + int ii; + +public: + virtual void Reset() { ii = -1; cont = start; } + virtual T& Get() const { ASSERT(ii>=0); return *cont->GetPtr(); } + virtual bool Next() { ++ii; return ((cont = cont->GetNext()) != start); } + + virtual IterLink* Copy() const { return new IterLink(*this); } + virtual IterLink* PartialCopy() const { IterLink* t = Copy(); t->Reset(); return t; } + + IterLink() : cont(NULL), ii(-1) {} + IterLink(Link& _cont) : cont(&_cont), start(&_cont), ii(-1) {} + IterLink(Link& _cont, int ii) : cont(&_cont), start(&_cont), ii(ii) {} +}; + +class IterCreator +{ +public: + +ITER_CONT(Vector) +ITER_CONT(Array) +ITER_CONT(BiVector) +ITER_CONT(BiArray) +ITER_CONT(Index) +ITER_CONT(ArrayIndex) +ITER_CONT(Segtor) + +ITER_PTR(Ptr) +ITER_PTR(One) +ITER_PTR(T*) + + template inline static Iter* GetIter(Any& cont) { ASSERT(cont.Is()); return new IterAny(cont); } \ + template inline static ConstIter* GetIter(const Any& cont) { ASSERT(cont.Is()); return new ConstIterAny(cont); } \ + + template inline static Iter* GetIter(Value& cont) { ASSERT(cont.Is()); return new IterValue(cont); } \ + template inline static ConstIter* GetIter(const Value& cont) { ASSERT(cont.Is()); return new ConstIterValue(cont); } \ + + template inline static Iter* GetIter(Link& cont) { return new IterLink(cont); } \ + template inline static ConstIter* GetIter(const Link& cont) { return new ConstIterLink(cont); } \ + +private: + IterCreator(); + IterCreator(const IterCreator&); + ~IterCreator(); +}; + +//use these to manage scope destrying +#define ITER(type) One > +#define ITERC(type) One > + +#define FOREACHCONT(type, var, cont) \ +for(int __i = 0, __c = (cont).GetCount(), __b; __b = 1,__i < __c; ++__i) \ + for(type& var = (cont)[__i]; __b; __b = 0) \ + + +#define FOREACHCONTC(type, var, cont) \ +for(int __i = 0, __c = (cont).GetCount(), __b; __b = 1,__i < __c; ++__i) \ + for(const type& var = (cont)[__i]; __b; __b = 0) \ + + +#define FOREACH(type, var, cont) \ +if(int __b = 1) \ +for(One > __it = IterCreator::GetIter(cont); __b = 1, __it->Next(); ) \ + for(type& var = __it->Get(); __b; __b = 0)\ + + +#define FOREACHC(type, var, cont) \ +if(int __b = 1) \ +for(One > __it = IterCreator::GetIter(cont); __b = 1, __it->Next(); ) \ + for(const type& var = __it->Get(); __b; __b = 0)\ + +#endif diff --git a/bazaar/Iter/Iter.upp b/bazaar/Iter/Iter.upp new file mode 100644 index 000000000..370e0b230 --- /dev/null +++ b/bazaar/Iter/Iter.upp @@ -0,0 +1,10 @@ +description "Iterator Interface for common containers\377"; + +uses + Core, + Gen; + +file + Iter.h, + Iter.cpp; + diff --git a/bazaar/Iter/init b/bazaar/Iter/init new file mode 100644 index 000000000..219e5226b --- /dev/null +++ b/bazaar/Iter/init @@ -0,0 +1,5 @@ +#ifndef _Iter_icpp_init_stub +#define _Iter_icpp_init_stub +#include "Core/init" +#include "Gen/init" +#endif diff --git a/bazaar/IterTest/IterTest.h b/bazaar/IterTest/IterTest.h new file mode 100644 index 000000000..f7f88f7c8 --- /dev/null +++ b/bazaar/IterTest/IterTest.h @@ -0,0 +1,27 @@ +#ifndef _IterTest_IterTest_h +#define _IterTest_IterTest_h + +#include + +using namespace Upp; + +#define LAYOUTFILE +#include + +#include + +class Foo : public Link +{ +public: + int d; +}; + + +class IterTest : public WithIterTestLayout { +public: + typedef IterTest CLASSNAME; + IterTest(); +}; + +#endif + diff --git a/bazaar/IterTest/IterTest.lay b/bazaar/IterTest/IterTest.lay new file mode 100644 index 000000000..8ef25b63d --- /dev/null +++ b/bazaar/IterTest/IterTest.lay @@ -0,0 +1,3 @@ +LAYOUT(IterTestLayout, 200, 100) +END_LAYOUT + diff --git a/bazaar/IterTest/IterTest.upp b/bazaar/IterTest/IterTest.upp new file mode 100644 index 000000000..68d23a068 --- /dev/null +++ b/bazaar/IterTest/IterTest.upp @@ -0,0 +1,14 @@ +description "Test package for Iter Iterator interface\377"; + +uses + CtrlLib, + Iter; + +file + IterTest.h, + main.cpp, + IterTest.lay; + +mainconfig + "" = "GUI MT"; + diff --git a/bazaar/IterTest/init b/bazaar/IterTest/init new file mode 100644 index 000000000..b43508ff4 --- /dev/null +++ b/bazaar/IterTest/init @@ -0,0 +1,5 @@ +#ifndef _IterTest_icpp_init_stub +#define _IterTest_icpp_init_stub +#include "CtrlLib/init" +#include "Iter/init" +#endif diff --git a/bazaar/IterTest/main.cpp b/bazaar/IterTest/main.cpp new file mode 100644 index 000000000..a58a7b162 --- /dev/null +++ b/bazaar/IterTest/main.cpp @@ -0,0 +1,147 @@ +#include "IterTest.h" + +void CommonHandler(Iter& ii) +{ + while(ii.Next()) + ii.Get() = Random(); +} + +IterTest::IterTest() +{ + CtrlLayout(*this, "Window title"); + + //generally, an iter interface needs its underlying container to live as long as interface is present. + //no checks are performed to keep code small + //an Iter interface will not modify the underlying container. + //if container is changed while an Iter interface is bound to it, it may become undefined in behaviour (Vector i.e) + //an Iter interface is always created on heap, so use means to delete it after usage, best is One > foo, destroyed when scope is left + + //========================================================================================== + + //Vector or any common linear container + + Vector vi; + vi.SetCount(10); + + //use the explicit interface to do things + One > ii = IterCreator::GetIter(vi); + while(ii->Next()) + ii->Get() = Random(); + + //an iterator can be copied, without knowing its underlying type + //and can be reinitiated + One > ii2 = ii->PartialCopy(); + while(ii2->Next()) + LOG(ii2->Get()); + + //the const variant of Iter, ConstIter + One > ii3 = IterCreator::GetIter((const Vector&)vi); + while(ii3->Next()) + LOG(ii3->Get()); + + FOREACH(int, e, vi) + LOG(e); + + //and the const version + FOREACHC(int, e, (const Vector&)vi) + LOG(e); + + //helpers to define the scope safe iterators + ITER(int) _ii = IterCreator::GetIter(vi); + ITERC(int) _cii = IterCreator::GetIter((const Vector&)vi); + + //a macro for usual containers only without using Iter interface + //can speed up things because no virtual stuff involved + FOREACHCONT(int, e, vi) + LOG(e); + + //the const variant + FOREACHCONTC(int, e, (const Vector&)vi) + LOG(e); + + //other 'containers' also yield a Iter interface + + //usual pointer + + int in = 123; + int* inp = ∈ + + FOREACH(int, e, inp) + LOG(e); + + FOREACHC(int, e, (const int*)inp) + LOG(e); + + //Ptr + + EditInt ei; + Ptr eip(&ei); + + FOREACH(Ctrl, e, eip) + e.SetData(123); + + FOREACHC(Ctrl, e, (const Ptr&)eip) + e.GetData(); + + //One + + One oei; + oei.Create(); + + FOREACH(Ctrl, e, oei) + e.SetData(123); + + FOREACHC(Ctrl, e, (const One&)oei) + e.GetData(); + + //Any + + Any a; + a.Create() = 345; + One > ia = IterCreator::GetIter(a); + + FOREACH(int, e, a) + LOG(e); + + FOREACHC(int, e, (const Any&)a) + LOG(e); + + //Value + + Value v = 789; + One > iv = IterCreator::GetIter(v); + + FOREACH(int, e, v) + LOG(e); + + FOREACHC(int, e, (const Value&)v) + LOG(e); + + //Link + + LinkOwner lf; + for(int i = 0; i < 10; i++) + lf.InsertPrev()->d = i; + + FOREACH(Foo, e, (Link&)lf) + LOG(e.d); + + FOREACHC(Foo, e, (const Link&)lf) + LOG(e.d); + + //all containers can be handled in a common interface + ITER(int) iii; + + iii = IterCreator::GetIter(vi); + CommonHandler(*iii); + + Array ai; + iii = IterCreator::GetIter(ai); + CommonHandler(*iii); +} + +GUI_APP_MAIN +{ + IterTest().Run(); +} + diff --git a/bazaar/LogPosCtrl/LogPosCtrl.cpp b/bazaar/LogPosCtrl/LogPosCtrl.cpp new file mode 100644 index 000000000..22cadd446 --- /dev/null +++ b/bazaar/LogPosCtrl/LogPosCtrl.cpp @@ -0,0 +1,317 @@ +#include "LogPosCtrl.h" + +static void sLay1(int& pos, int& r, int align, int a, int b, int sz) +{ + pos = a; + int size = b; + switch(align) { + case Ctrl::CENTER: + pos = (sz - b) / 2 + a; + break; + case Ctrl::RIGHT: + pos = sz - (a + b); + break; + case Ctrl::SIZE: + size = sz - (a + b); + break; + } + r = pos + max(size, 0); +} + +Rect LogPosPopUp::CtrlRect(Ctrl::LogPos pos, Size sz) +{ + Rect r; + sLay1(r.left, r.right, pos.x.GetAlign(), pos.x.GetA(), pos.x.GetB(), sz.cx); + sLay1(r.top, r.bottom, pos.y.GetAlign(), pos.y.GetA(), pos.y.GetB(), sz.cy); + return r; +} + +Ctrl::Logc MakeLogc(int align, int a, int b, int sz) +{ + int isz = b - a; + switch(align) { + case Ctrl::LEFT: + return Ctrl::PosLeft(a, isz); + case Ctrl::RIGHT: + return Ctrl::PosRight(sz - b, isz); + case Ctrl::CENTER: + return Ctrl::PosCenter(isz, a - (sz - isz) / 2); + } + return Ctrl::PosSize(a, sz - b); +} + +Ctrl::LogPos LogPosPopUp::MakeLogPos(int ax, int ay, const Rect& r, Size sz) +{ + return Ctrl::LogPos(MakeLogc(ax, r.left, r.right, sz.cx), + MakeLogc(ay, r.top, r.bottom, sz.cy)); +} + +Ctrl::LogPos LogPosPopUp::MakeLogPos(Ctrl::LogPos p, const Rect& r, Size sz) +{ + return MakeLogPos(p.x.GetAlign(), p.y.GetAlign(), r, sz); +} + +Ctrl::LogPos LogPosPopUp::ReAlign(const Ctrl& c, const Ctrl::LogPos& npos) +{ + if(!c.GetParent()) return npos; + //convert ctrl's pos to its rect in parent + //and reconvert to logpos using new align + Size sz = c.GetParent()->GetSize(); + Ctrl::LogPos pos = c.GetPos(); + Rect r = CtrlRect(pos, sz); + pos = MakeLogPos(npos, r, sz); + return pos; +} + +void LogPosPopUp::Set(const Ctrl::LogPos& p) +{ + pos = p; + xa <<= pos.x.GetA(); xb <<= pos.x.GetB(); + switch(pos.x.GetAlign()) + { + case Ctrl::LEFT: l <<= true; r <<= false; break; + case Ctrl::RIGHT: l <<= false; r <<= true; break; + case Ctrl::SIZE: l <<= true; r <<= true; break; + default: + case Ctrl::CENTER: l <<= false; r <<= false; break; + } + ya <<= pos.y.GetA(); yb <<= pos.y.GetB(); + switch(pos.y.GetAlign()) + { + case Ctrl::TOP: u <<= true; d <<= false; break; + case Ctrl::BOTTOM: u <<= false; d <<= true; break; + case Ctrl::SIZE: u <<= true; d <<= true; break; + default: + case Ctrl::CENTER: u <<= false; d <<= false; break; + } +} + +void LogPosPopUp::Updated() +{ + switch(pos.x.GetAlign()) + { + case Ctrl::LEFT: sxa.SetText("Marg L"); sxb.SetText("Size"); sxn.SetText("Left"); break; + case Ctrl::RIGHT: sxa.SetText("Marg R"); sxb.SetText("Size"); sxn.SetText("Right"); break; + case Ctrl::SIZE: sxa.SetText("Marg L"); sxb.SetText("Marg R"); sxn.SetText("HFill"); break; + default: + case Ctrl::CENTER: sxa.SetText("Offs"); sxb.SetText("Size"); sxn.SetText("HCenter"); break; + } + switch(pos.y.GetAlign()) + { + case Ctrl::TOP: sya.SetText("Marg U"); syb.SetText("Size"); syn.SetText("Top"); break; + case Ctrl::BOTTOM: sya.SetText("Marg D"); syb.SetText("Size"); syn.SetText("Bottom"); break; + case Ctrl::SIZE: sya.SetText("Marg U"); syb.SetText("Marg D"); syn.SetText("VFill"); break; + default: + case Ctrl::CENTER: sya.SetText("Offs"); syb.SetText("Size"); syn.SetText("VCenter"); break; + } +} + +//obsolete +Ctrl::LogPos LogPosPopUp::Generate() const +{ + Ctrl::LogPos pos; + int q; + + q = 0; + q |= ((l)?(1):(0)); + q |= ((r)?(2):(0)); + switch(q) + { + case 1: pos.x.SetAlign(Ctrl::LEFT); break; + case 2: pos.x.SetAlign(Ctrl::RIGHT); break; + case 3: pos.x.SetAlign(Ctrl::SIZE); break; + default: + case 0: pos.x.SetAlign(Ctrl::CENTER); break; + } + pos.x.SetA(xa); pos.x.SetB(xb); + + q = 0; + q |= ((u)?(1):(0)); + q |= ((d)?(2):(0)); + switch(q) + { + case 1: pos.y.SetAlign(Ctrl::TOP); break; + case 2: pos.y.SetAlign(Ctrl::BOTTOM); break; + case 3: pos.y.SetAlign(Ctrl::SIZE); break; + default: + case 0: pos.y.SetAlign(Ctrl::CENTER); break; + } + pos.y.SetA(ya); pos.y.SetB(yb); + + return pos; +} + +void LogPosPopUp::XaCB() +{ + pos.x.SetA(xa); + WhenSizeChange(); + UpdateAction(); +} +void LogPosPopUp::XbCB() +{ + pos.x.SetB(xb); + WhenSizeChange(); + UpdateAction(); +} +void LogPosPopUp::YaCB() +{ + pos.y.SetA(ya); + WhenSizeChange(); + UpdateAction(); +} +void LogPosPopUp::YbCB() +{ + pos.y.SetB(yb); + WhenSizeChange(); + UpdateAction(); +} +void LogPosPopUp::XAlignCB() +{ + int q = 0; + q |= ((l)?(1):(0)); + q |= ((r)?(2):(0)); + switch(q) + { + case 1: pos.x.SetAlign(Ctrl::LEFT); break; + case 2: pos.x.SetAlign(Ctrl::RIGHT); break; + case 3: pos.x.SetAlign(Ctrl::SIZE); break; + default: + case 0: pos.x.SetAlign(Ctrl::CENTER); break; + } + WhenAlignChange(); + UpdateAction(); +} +void LogPosPopUp::YAlignCB() +{ + int q = 0; + q |= ((u)?(1):(0)); + q |= ((d)?(2):(0)); + switch(q) + { + case 1: pos.y.SetAlign(Ctrl::TOP); break; + case 2: pos.y.SetAlign(Ctrl::BOTTOM); break; + case 3: pos.y.SetAlign(Ctrl::SIZE); break; + default: + case 0: pos.y.SetAlign(Ctrl::CENTER); break; + } + WhenAlignChange(); + UpdateAction(); +} + +LogPosPopUp::LogPosPopUp() +{ + CtrlLayout(*this); + SetFrame(BlackFrame()); + + l.SetLabel("<"); + r.SetLabel(">"); + u.SetLabel("/\\"); + d.SetLabel("\\/"); + + xa <<= THISBACK(XaCB); + xb <<= THISBACK(XbCB); + ya <<= THISBACK(YaCB); + yb <<= THISBACK(YbCB); + + l <<= THISBACK(XAlignCB); + r <<= THISBACK(XAlignCB); + u <<= THISBACK(YAlignCB); + d <<= THISBACK(YAlignCB); + + ok <<= THISBACK(Acceptor); + cancel <<= THISBACK(Rejector); +} + +NAMESPACE_UPP +template<> +String AsString(const Ctrl::LogPos& pos) +{ + String s; + int xa = pos.x.GetA(), xb = pos.x.GetB(); + switch(pos.x.GetAlign()) + { + case Ctrl::LEFT: s << "Left(mr:" << xa << ",sz:" << xb << ")"; break; + case Ctrl::RIGHT: s << "Right(mr:" << xa << ",sz:" << xb << ")"; break; + case Ctrl::SIZE: s << "HSize(mr:" << xa << ",mr:" << xb << ")"; break; + default: + case Ctrl::CENTER: s << "HCent(of:" << xa << ",sz:" << xb << ")"; break; + } + s << "."; + int ya = pos.y.GetA(), yb = pos.y.GetB(); + switch(pos.y.GetAlign()) + { + case Ctrl::TOP: s << "Top(mr:" << ya << ",sz:" << yb << ")"; break; + case Ctrl::BOTTOM: s << "Bottom(mr:" << ya << ",sz:" << yb << ")"; break; + case Ctrl::SIZE: s << "VSize(mr:" << ya << ",mr:" << yb << ")"; break; + default: + case Ctrl::CENTER: s << "VCent(of:" << ya << ",sz:" << yb << ")"; break; + } + return s; +} +END_UPP_NAMESPACE + +LogPosCtrl::LogPosCtrl() : push(false) +{ + IgnoreMouse(false); + + lc.WhenSelect = THISBACK(AcceptDrop); + lc.WhenCancel = THISBACK(CloseDrop); + lc.WhenAction = THISBACK(ActionDrop); + + lc.WhenSizeChange = THISBACK(OnSizeChange); + lc.WhenAlignChange = THISBACK(OnAlignChange); +} + +void LogPosCtrl::LeftDown(Point p, dword keyflags) +{ + if(!HasFocus()) SetFocus(); + Drop(); +} + +void LogPosCtrl::Drop() +{ + if(push) return; + push = true; + savedpos = pos; + lc.PopUp(this, pos); +} + +void LogPosCtrl::CloseDrop() +{ + push = false; + if(pos != savedpos) { + pos = savedpos; + OnSizeChange(); //restore + UpdateAction(); + } +} + +void LogPosCtrl::AcceptDrop() +{ + push = false; + pos = lc.Get(); + UpdateAction(); +} + +void LogPosCtrl::ActionDrop() +{ + pos = lc.Get(); + UpdateAction(); +} + +void LogPosCtrl::Updated() +{ + SetText(AsString(pos)); +} + +void LogPosCtrl::OnSizeChange() +{ + if(!posparent) return; +} + +void LogPosCtrl::OnAlignChange() +{ + if(!posparent) return; + lc.Set(LogPosPopUp::ReAlign(*posparent, lc.Get())); + lc.Update(); //feedback to lc +} diff --git a/bazaar/LogPosCtrl/LogPosCtrl.h b/bazaar/LogPosCtrl/LogPosCtrl.h new file mode 100644 index 000000000..0a504d984 --- /dev/null +++ b/bazaar/LogPosCtrl/LogPosCtrl.h @@ -0,0 +1,85 @@ +#ifndef _LogPosCtrl_LogPosCtrl_h +#define _LogPosCtrl_LogPosCtrl_h + +#include + +using namespace Upp; + +#define LAYOUTFILE +#include + +#include + +const dword LOGPOS_V = 20; +NAMESPACE_UPP +template<> inline dword ValueTypeNo(const Ctrl::LogPos*) { return LOGPOS_V; } +END_UPP_NAMESPACE + +class LogPosPopUp : public WithLogPosPopUpLayout { +public: + typedef LogPosPopUp CLASSNAME; + LogPosPopUp(); + + static Rect CtrlRect(Ctrl::LogPos pos, Size sz); + static Ctrl::LogPos MakeLogPos(int ax, int ay, const Rect& r, Size sz); + static Ctrl::LogPos MakeLogPos(Ctrl::LogPos p, const Rect& r, Size sz); + static Ctrl::LogPos ReAlign(const Ctrl& c, const Ctrl::LogPos& npos); + + virtual void Updated(); + virtual Value GetData() const { return RawToValue(pos); } + virtual void SetData(const Value& v) { if(!v.Is()) return; Set(RawValue::Extract(v)); Update(); } + + Ctrl::LogPos Generate() const; //obsolete + Ctrl::LogPos Get() const { return pos; } + void Set(const Ctrl::LogPos& p); + void PopUp(Ctrl* owner, const Ctrl::LogPos& p) { Set(p); Update(); PopUpC::PopUp(owner); } + + Callback WhenSizeChange; + Callback WhenAlignChange; + +protected: + void XaCB(); + void XbCB(); + void YaCB(); + void YbCB(); + void XAlignCB(); + void YAlignCB(); + + Ctrl::LogPos pos; +}; + +NAMESPACE_UPP +template<> String AsString(const Ctrl::LogPos& pos); +END_UPP_NAMESPACE + +class LogPosCtrl : public StaticText +{ +public: + typedef LogPosCtrl CLASSNAME; + LogPosCtrl(); + + virtual void LeftDown(Point p, dword keyflags); + virtual void Updated(); + virtual Value GetData() const { return RawToValue(pos); } + virtual void SetData(const Value& v) { if(!v.Is()) return; pos = RawValue::Extract(v); Update(); } + + Ctrl::LogPos Get() const { return pos; } + void Set(const Ctrl::LogPos& p) { pos = p; Update(); } + void Set(Ctrl& c) { posparent = &c; pos = c.GetPos(); Update(); } + void Drop(); + +protected: + void CloseDrop(); + void AcceptDrop(); + void ActionDrop(); + void OnSizeChange(); + void OnAlignChange(); + + Ctrl::LogPos pos, savedpos; + bool push; + LogPosPopUp lc; + Ptr posparent; +}; + +#endif + diff --git a/bazaar/LogPosCtrl/LogPosCtrl.lay b/bazaar/LogPosCtrl/LogPosCtrl.lay new file mode 100644 index 000000000..d4c145ffb --- /dev/null +++ b/bazaar/LogPosCtrl/LogPosCtrl.lay @@ -0,0 +1,21 @@ +LAYOUT(LogPosCtrlLayout, 232, 120) + ITEM(ButtonOption, l, LeftPosZ(0, 20).TopPosZ(20, 60)) + ITEM(ButtonOption, r, LeftPosZ(80, 20).TopPosZ(20, 60)) + ITEM(ButtonOption, u, LeftPosZ(20, 60).TopPosZ(0, 20)) + ITEM(ButtonOption, d, LeftPosZ(20, 60).TopPosZ(80, 20)) + ITEM(StaticText, sxn, SetAlign(ALIGN_CENTER).LeftPosZ(20, 60).TopPosZ(28, 19)) + ITEM(StaticText, syn, SetAlign(ALIGN_CENTER).LeftPosZ(20, 60).TopPosZ(52, 19)) + ITEM(StaticText, sxa, SetAlign(ALIGN_RIGHT).LeftPosZ(124, 44).TopPosZ(8, 19)) + ITEM(EditIntSpin, xa, NotNull(true).LeftPosZ(108, 60).TopPosZ(28, 20)) + ITEM(StaticText, sxb, SetAlign(ALIGN_RIGHT).LeftPosZ(172, 60).TopPosZ(8, 19)) + ITEM(EditIntSpin, xb, NotNull(true).LeftPosZ(172, 60).TopPosZ(28, 20)) + ITEM(StaticText, sya, SetAlign(ALIGN_RIGHT).LeftPosZ(124, 44).TopPosZ(52, 19)) + ITEM(EditIntSpin, ya, NotNull(true).LeftPosZ(108, 60).TopPosZ(72, 20)) + ITEM(StaticText, syb, SetAlign(ALIGN_RIGHT).LeftPosZ(172, 60).TopPosZ(52, 19)) + ITEM(EditIntSpin, yb, NotNull(true).LeftPosZ(172, 60).TopPosZ(72, 20)) + ITEM(Button, ok, SetLabel(t_("OK")).LeftPosZ(120, 56).TopPosZ(100, 19)) + ITEM(Button, cancel, SetLabel(t_("Cancel")).LeftPosZ(176, 56).TopPosZ(100, 19)) + ITEM(StaticText, dv___16, SetText(t_("X:")).LeftPosZ(108, 12).TopPosZ(8, 19)) + ITEM(StaticText, dv___17, SetText(t_("Y:")).LeftPosZ(108, 12).TopPosZ(52, 19)) +END_LAYOUT + diff --git a/bazaar/LogPosCtrl/LogPosCtrl.upp b/bazaar/LogPosCtrl/LogPosCtrl.upp new file mode 100644 index 000000000..7752e35bc --- /dev/null +++ b/bazaar/LogPosCtrl/LogPosCtrl.upp @@ -0,0 +1,11 @@ +description "Editing Ctrl::LogPos\377"; + +uses + CtrlLib, + PopUpC; + +file + LogPosPopUp.lay, + LogPosCtrl.h, + LogPosCtrl.cpp; + diff --git a/bazaar/LogPosCtrl/LogPosPopUp.lay b/bazaar/LogPosCtrl/LogPosPopUp.lay new file mode 100644 index 000000000..e1fe30445 --- /dev/null +++ b/bazaar/LogPosCtrl/LogPosPopUp.lay @@ -0,0 +1,21 @@ +LAYOUT(LogPosPopUpLayout, 232, 120) + ITEM(ButtonOption, l, LeftPosZ(0, 20).TopPosZ(20, 60)) + ITEM(ButtonOption, r, LeftPosZ(80, 20).TopPosZ(20, 60)) + ITEM(ButtonOption, u, LeftPosZ(20, 60).TopPosZ(0, 20)) + ITEM(ButtonOption, d, LeftPosZ(20, 60).TopPosZ(80, 20)) + ITEM(StaticText, sxn, SetAlign(ALIGN_CENTER).LeftPosZ(20, 60).TopPosZ(28, 19)) + ITEM(StaticText, syn, SetAlign(ALIGN_CENTER).LeftPosZ(20, 60).TopPosZ(52, 19)) + ITEM(StaticText, sxa, SetAlign(ALIGN_RIGHT).LeftPosZ(124, 44).TopPosZ(8, 19)) + ITEM(EditIntSpin, xa, NotNull(true).LeftPosZ(108, 60).TopPosZ(28, 20)) + ITEM(StaticText, sxb, SetAlign(ALIGN_RIGHT).LeftPosZ(172, 60).TopPosZ(8, 19)) + ITEM(EditIntSpin, xb, NotNull(true).LeftPosZ(172, 60).TopPosZ(28, 20)) + ITEM(StaticText, sya, SetAlign(ALIGN_RIGHT).LeftPosZ(124, 44).TopPosZ(52, 19)) + ITEM(EditIntSpin, ya, NotNull(true).LeftPosZ(108, 60).TopPosZ(72, 20)) + ITEM(StaticText, syb, SetAlign(ALIGN_RIGHT).LeftPosZ(172, 60).TopPosZ(52, 19)) + ITEM(EditIntSpin, yb, NotNull(true).LeftPosZ(172, 60).TopPosZ(72, 20)) + ITEM(Button, ok, SetLabel(t_("OK")).LeftPosZ(120, 56).TopPosZ(100, 19)) + ITEM(Button, cancel, SetLabel(t_("Cancel")).LeftPosZ(176, 56).TopPosZ(100, 19)) + ITEM(StaticText, dv___16, SetText(t_("X:")).LeftPosZ(108, 12).TopPosZ(8, 19)) + ITEM(StaticText, dv___17, SetText(t_("Y:")).LeftPosZ(108, 12).TopPosZ(52, 19)) +END_LAYOUT + diff --git a/bazaar/LogPosCtrl/init b/bazaar/LogPosCtrl/init new file mode 100644 index 000000000..c56c31218 --- /dev/null +++ b/bazaar/LogPosCtrl/init @@ -0,0 +1,5 @@ +#ifndef _LogPosCtrl_icpp_init_stub +#define _LogPosCtrl_icpp_init_stub +#include "CtrlLib/init" +#include "PopUpC/init" +#endif diff --git a/bazaar/LogPosCtrlTest/LogPosCtrlTest.h b/bazaar/LogPosCtrlTest/LogPosCtrlTest.h new file mode 100644 index 000000000..40da8948e --- /dev/null +++ b/bazaar/LogPosCtrlTest/LogPosCtrlTest.h @@ -0,0 +1,26 @@ +#ifndef _LogPosCtrlTest_LogPosCtrlTest_h +#define _LogPosCtrlTest_LogPosCtrlTest_h + +#include + +using namespace Upp; + +#include + +#define LAYOUTFILE +#include + +#include + +class LogPosCtrlTest : public WithLogPosCtrlTestLayout { +public: + typedef LogPosCtrlTest CLASSNAME; + LogPosCtrlTest(); + + void ChangeLogPosCB(); + + LogPosCtrl le; +}; + +#endif + diff --git a/bazaar/LogPosCtrlTest/LogPosCtrlTest.lay b/bazaar/LogPosCtrlTest/LogPosCtrlTest.lay new file mode 100644 index 000000000..1885f2579 --- /dev/null +++ b/bazaar/LogPosCtrlTest/LogPosCtrlTest.lay @@ -0,0 +1,8 @@ +LAYOUT(LogPosCtrlTestLayout, 492, 196) + ITEM(ArrayCtrl, ac, LeftPosZ(8, 190).TopPosZ(8, 96)) +END_LAYOUT + +LAYOUT(LogPosCtrlDlg, 400, 200) + ITEM(Button, ok, SetLabel(t_("OK")).HCenterPosZ(56, 0).BottomPosZ(5, 19)) +END_LAYOUT + diff --git a/bazaar/LogPosCtrlTest/LogPosCtrlTest.upp b/bazaar/LogPosCtrlTest/LogPosCtrlTest.upp new file mode 100644 index 000000000..79b12cefb --- /dev/null +++ b/bazaar/LogPosCtrlTest/LogPosCtrlTest.upp @@ -0,0 +1,14 @@ +description "Editing Ctrl::LogPos\377"; + +uses + CtrlLib, + LogPosCtrl; + +file + LogPosCtrlTest.h, + main.cpp, + LogPosCtrlTest.lay; + +mainconfig + "" = "GUI"; + diff --git a/bazaar/LogPosCtrlTest/main.cpp b/bazaar/LogPosCtrlTest/main.cpp new file mode 100644 index 000000000..84f63c192 --- /dev/null +++ b/bazaar/LogPosCtrlTest/main.cpp @@ -0,0 +1,25 @@ +#include "LogPosCtrlTest.h" + +void LogPosCtrlTest::ChangeLogPosCB() +{ + ac.SetPos(le.Get()); +} + +LogPosCtrlTest::LogPosCtrlTest() +{ + CtrlLayout(*this, "Window title"); + Sizeable().Zoomable(); + + Add(le.LeftPos(10, 200).BottomPos(10, 20)); + le <<= THISBACK(ChangeLogPosCB); + + //init + Ctrl& c = ac; + le.Set(c); +} + +GUI_APP_MAIN +{ + LogPosCtrlTest().Run(); +} + diff --git a/bazaar/PointCtrl/PointCtrl.cpp b/bazaar/PointCtrl/PointCtrl.cpp new file mode 100644 index 000000000..479fff5f7 --- /dev/null +++ b/bazaar/PointCtrl/PointCtrl.cpp @@ -0,0 +1,159 @@ +#include "PointCtrl.h" + +CH_STYLE(PointCtrl, Style, StyleDefault) +{ + backcol = SColorPaper(); + linecol = Blue(); + pointcol = LtRed(); + linesize = 1; + pointsize = 4; +} + +PointCtrl::PointCtrl() + : pressed(false), moving(false), di(-1) +{ + style = &StyleDefault(); + sxp.Clear(); + xp.SetNull(); + + vsx.MinMax(0,100); + vsy.MinMax(0,100); + + for(int i = 0; i < 10; i++) + vpd.Add().col = HsvColorf(i/(double)10, 1.0, 1.0); + + Update(); +} + +void PointCtrl::Paint(Draw& w) +{ + w.DrawRect(sz, style->backcol); + + //points + for(int i = 0; i < vp.GetCount(); i++) + { + const XY& _dp = vp[i]; + XY _p((int) psx(vsx, _dp.x), (int) psy(vsy, _dp.y)); + const PData& pd = vpd.At(i); + Rect r(_p,_p); r.Inflate(pd.size); + w.DrawEllipse(r, pd.col); + } + + //cross + if(!xp.IsNullInstance()) + { + w.DrawLine(xp.x-3,xp.y, xp.x+3+1,xp.y, style->linesize, style->linecol); + w.DrawLine(xp.x,xp.y-3, xp.x,xp.y+3+1, style->linesize, style->linecol); + + //target lines + if(pressed && moving) + { + w.DrawLine(0,xp.y, sz.cx,xp.y, style->linesize, style->linecol); + w.DrawLine(xp.x,0, xp.x,sz.cy, style->linesize, style->linecol); + } + } + + //square + Rect r(sxp, sxp); r.Inflate(style->pointsize); + Vector vp; + vp << r.TopLeft() << r.TopRight() << r.BottomRight() << r.BottomLeft() << r.TopLeft(); + w.DrawPolyline(vp, style->linesize, style->pointcol); + + //dot + w.DrawLine(sxp.x, sxp.y, sxp.x, sxp.y, 2, style->pointcol); +} + +void PointCtrl::LeftDown(Point p, dword keyflags) +{ + SetCapture(); + moving = false; + pressed = (keyflags & K_MOUSELEFT); + + xp = p; + sxp = xp; + + //point drag + for(int i = 0; i < vp.GetCount(); i++) + { + XY& _dp = vp[i]; + Point _p(int(psx(vsx, _dp.x)), int(psy(vsy, _dp.y))); + Rect r(_p, _p); r.Inflate(4); + if(!r.Contains(p)) continue; + di = i; break; + } + UpdateActionRefresh(); +} + +void PointCtrl::LeftRepeat(Point p, dword keyflags) +{ + if(moving) return; + + if(di<0 && !(keyflags & K_CTRL)) + { + di = vp.GetCount(); + XY& _dp = vp.Add(XY(vsx(psx, sxp.x), vsy(psy, sxp.y))); + WhenAddPoint(); + } + else if(di>=0 && (keyflags & K_CTRL)) + { + vp.Remove(di); + WhenRemovePoint(di); + di = -1; + moving = true; + } + else return; + + Refresh(); +} + +void PointCtrl::MouseMove(Point p, dword keyflags) +{ + moving = true; + pressed = (keyflags & K_MOUSELEFT); + + //clip + Point pp(minmax(p.x, 0, sz.cx), minmax(p.y, 0, sz.cy)); + if(xp == pp) return; + xp = pp; + + if(pressed) + { + sxp = xp; + if(di>=0) + { + vp[di] = XY(vsx(psx, sxp.x), vsy(psy, sxp.y)); + WhenMovePoint(di); + } + UpdateActionRefresh(); + } + else Refresh(); +} + +void PointCtrl::LeftUp(Point p, dword keyflags) +{ + ReleaseCapture(); + pressed = false; + moving = false; + di = -1; + xp.SetNull(); + Refresh(); +} + +void PointCtrl::Layout() +{ + sz = GetSize(); + psx.MinMax(0, sz.cx); + psy.MinMax(0, sz.cy); + UpdatedBack(); + Refresh(); +} + +void PointCtrl::Updated() +{ + vxp = XY(vsx(psx, sxp.x), vsy(psy, sxp.y)); +} + +void PointCtrl::UpdatedBack() +{ + sxp = Point(int(psx(vsx, vxp.x)), int(psy(vsy, vxp.y))); +} diff --git a/bazaar/PointCtrl/PointCtrl.h b/bazaar/PointCtrl/PointCtrl.h new file mode 100644 index 000000000..13f502860 --- /dev/null +++ b/bazaar/PointCtrl/PointCtrl.h @@ -0,0 +1,89 @@ +#ifndef _PointCtrl_PointCtrl_h +#define _PointCtrl_PointCtrl_h + +#include + +using namespace Upp; + +#include + +typedef Pointf XY; + +class PointCtrl : public Ctrl { +public: + typedef PointCtrl CLASSNAME; + PointCtrl(); + + struct Style : public ChStyle