diff --git a/uppsrc/CtrlLib/CtrlLib.h b/uppsrc/CtrlLib/CtrlLib.h index 781c89ebe..9c3c97996 100644 --- a/uppsrc/CtrlLib/CtrlLib.h +++ b/uppsrc/CtrlLib/CtrlLib.h @@ -44,6 +44,7 @@ class Bar; #include #include #include +#include #define LAYOUTFILE #include diff --git a/uppsrc/CtrlLib/CtrlLib.upp b/uppsrc/CtrlLib/CtrlLib.upp index 8ce3f27d7..267ba5bd2 100644 --- a/uppsrc/CtrlLib/CtrlLib.upp +++ b/uppsrc/CtrlLib/CtrlLib.upp @@ -55,6 +55,8 @@ file Help.cpp, DateTimeCtrl.h, DateTimeCtrl.cpp, + SuggestCtrl.h, + SuggestCtrl.cpp, Bar readonly separator, Bar.h, Bar.cpp, diff --git a/uppsrc/CtrlLib/SuggestCtrl.cpp b/uppsrc/CtrlLib/SuggestCtrl.cpp new file mode 100644 index 000000000..4a398a026 --- /dev/null +++ b/uppsrc/CtrlLib/SuggestCtrl.cpp @@ -0,0 +1,154 @@ +#include "CtrlLib.h" + +NAMESPACE_UPP + +void SuggestCtrl::CancelMode() +{ + Cancel(); +} + +int SuggestCtrl::IsDelimiter(int c) +{ + if(delimiter_filter) + c = (*delimiter_filter)(c); + if(delimiter_char && delimiter_char != c) + c = 0; + return c; +} + +WString SuggestCtrl::CF(const WString& src) +{ + return compare_filter ? UPP::Filter(src, compare_filter) : src; +} + +WString SuggestCtrl::ReadLast(int& h) +{ + int l; + GetSelection(l, h); + if(l != h) + return Null; + WString text = GetText(); + WString x; + while(--l >= 0 && !IsDelimiter(text[l])) { + h = l; + x.Insert(0, text[l]); + } + return Upp::TrimLeft(x); +} + +void SuggestCtrl::Select() +{ + if(list.IsCursor()) { + int h; + WString x = ReadLast(h); + int q; + if(GetSelection(q, q)) + return; + Remove(h, q - h); + x = list.GetKey(); + Insert(h, x); + h += x.GetCount(); + SetSelection(h, h); + Cancel(); + Action(); + } +} + +bool SuggestCtrl::Key(dword key, int count) +{ + if(list.IsOpen()) { + if(key == K_UP || key == K_PAGEUP || key == K_CTRL_PAGEDOWN) + if(list.IsCursor()) + return list.Key(key, count); + else { + list.GoEnd(); + return true; + } + if(key == K_DOWN || key == K_PAGEDOWN || key == K_CTRL_PAGEUP) + if(list.IsCursor()) + return list.Key(key, count); + else { + list.GoBegin(); + return true; + } + } + if(key == K_ENTER && list.IsOpen() && list.IsCursor()) { + Select(); + return true; + } + if(key == K_ESCAPE && list.IsOpen()) { + Close(); + return true; + } + int cc = IsDelimiter(key); + if(cc) + key = cc; + if(EditString::Key(key, count)) { + if(key >= 32 && key < 65536 || key == K_BACKSPACE || key == K_CTRL_SPACE) { + int h; + WString x = CF(ReadLast(h)); + list.Clear(); + for(int i = 0; i < data.GetCount(); i++) + if(CF(data[i]).Find(x) >= 0) + list.Add(data[i]); + if(list.GetCount() == 0) { + Cancel(); + return true; + } + Rect cr = GetCaretRect(h) + GetScreenView().TopLeft(); + Rect wr = GetWorkArea(); + int c = droplines * Draw::GetStdFontCy(); + Rect r(cr.BottomLeft(), Size(c, c)); + r.SetSize(c, c); + if(r.bottom > wr.bottom) { + r.top = cr.top - c; + r.bottom = r.top + c; + } + if(r.right > wr.right) { + r.left = cr.left - c; + r.right = r.left + c; + } + list.SetRect(r); + if(!list.IsOpen()) + list.Ctrl::PopUp(GetParent(), false, false, true); + } + else + Cancel(); + return true; + } + return false; +} + +void SuggestCtrl::Cancel() +{ + if(list.IsOpen()) + list.Close(); +} + +void SuggestCtrl::LostFocus() +{ + EditField::LostFocus(); + Cancel(); +} + +void SuggestCtrl::GotFocus() +{ + EditField::GotFocus(); + Move(GetLength()); +} + +SuggestCtrl::SuggestCtrl() +{ + list.AddColumn(); + list.NoHeader().NoGrid(); + list.SetFrame(BlackFrame()); + list.MouseMoveCursor(); + list.WhenLeftClick = THISBACK(Select); + list.NoWantFocus(); + delimiter_char = 0; + delimiter_filter = NULL; + droplines = 16; + compare_filter = NULL; +} + +END_UPP_NAMESPACE diff --git a/uppsrc/CtrlLib/SuggestCtrl.h b/uppsrc/CtrlLib/SuggestCtrl.h new file mode 100644 index 000000000..7932e4b56 --- /dev/null +++ b/uppsrc/CtrlLib/SuggestCtrl.h @@ -0,0 +1,36 @@ +class SuggestCtrl : public EditString { + virtual bool Key(dword key, int count); + virtual void CancelMode(); + virtual void LostFocus(); + virtual void GotFocus(); + +private: + Vector data; + ArrayCtrl list; + int droplines; + int delimiter_char; + int (*delimiter_filter)(int c); + int (*compare_filter)(int c); + + void Cancel(); + void Select(); + WString ReadLast(int& h); + int IsDelimiter(int c); + WString CF(const WString& src); + + typedef SuggestCtrl CLASSNAME; + +public: + void ClearList() { data.Clear(); } + void Add(const WString& s) { data.Add(s); } + void Add(const String& s) { data.Add(s.ToWString()); } + + void Pick(Vector rval_ list) { data = pick(list); } + + SuggestCtrl& SetDropLines(int n) { droplines = n; return *this; } + SuggestCtrl& Delimiter(int chr) { delimiter_char = chr; return *this; } + SuggestCtrl& Delimiter(int (*filter)(int c)) { delimiter_filter = filter; return *this; } + SuggestCtrl& CompareFilter(int (*filter)(int c)) { compare_filter = filter; return *this; } + + SuggestCtrl(); +}; diff --git a/uppsrc/CtrlLib/src.tpp/SuggestCtrl$en-us.tpp b/uppsrc/CtrlLib/src.tpp/SuggestCtrl$en-us.tpp new file mode 100644 index 000000000..0b1ee897e --- /dev/null +++ b/uppsrc/CtrlLib/src.tpp/SuggestCtrl$en-us.tpp @@ -0,0 +1,67 @@ +topic ""; +[2 $$0,0#00000000000000000000000000000000:Default] +[i448;a25;kKO9;2 $$1,0#37138531426314131252341829483380:class] +[l288;2 $$2,2#27521748481378242620020725143825:desc] +[0 $$3,0#96390100711032703541132217272105:end] +[H6;0 $$4,0#05600065144404261032431302351956:begin] +[i448;a25;kKO9;2 $$5,0#37138531426314131252341829483370:item] +[l288;a4;*@5;1 $$6,6#70004532496200323422659154056402:requirement] +[l288;i1121;b17;O9;~~~.1408;2 $$7,0#10431211400427159095818037425705:param] +[i448;b42;O9;2 $$8,8#61672508125594000341940100500538:tparam] +[b42;2 $$9,9#13035079074754324216151401829390:normal] +[{_} +[ {{10000@(113.42.0) [s0;%% [*@7;4 SuggestCtrl]]}}&] +[s0;i448;a25;kKO9; &] +[s1;:SuggestCtrl`:`:class: [@(0.0.255)3 class][3 _][*3 SuggestCtrl][3 _:_][@(0.0.255)3 public][3 _ +][*@3;3 EditString]&] +[s0; &] +[s0;i448;a25;kKO9; [@(0.0.255) +@@image:1152&1170 +(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) +]&] +[s0;i448;a25;kKO9;@(0.0.255) &] +[s0;i448;a25;kKO9; This widget complements EditString with suggestions. +&] +[s0;i448;a25;kKO9;@(0.0.255) &] +[ {{10000F(128)G(128)@1 [s0;%% [* Public Member List]]}}&] +[s3; &] +[s5;:SuggestCtrl`:`:ClearList`(`): [@(0.0.255) void]_[* ClearList]()&] +[s2;%% Clears the suggestions list.&] +[s3; &] +[s4; &] +[s5;:SuggestCtrl`:`:Add`(const WString`&`): [@(0.0.255) void]_[* Add]([@(0.0.255) const]_[_^WString^ W +String][@(0.0.255) `&]_[*@3 s])&] +[s5;:SuggestCtrl`:`:Add`(const String`&`): [@(0.0.255) void]_[* Add]([@(0.0.255) const]_[_^String^ S +tring][@(0.0.255) `&]_[*@3 s])&] +[s2;%% Adds [%-*@3 s] to suggestions list.&] +[s3;%% &] +[s4;%% &] +[s5;:SuggestCtrl`:`:Pick`(Vector`rval`_`): [@(0.0.255) void]_[* Pick]([_^Vector^ V +ector]<[_^WString^ WString]>_[@(0.0.255) rval`_]_[*@3 list])&] +[s2;%% Picks [%-*@3 list] to replace suggestions list.&] +[s3;%% &] +[s4;%% &] +[s5;:SuggestCtrl`:`:SetDropLines`(int`): [_^SuggestCtrl^ SuggestCtrl][@(0.0.255) `&]_[* Set +DropLines]([@(0.0.255) int]_[*@3 n])&] +[s2;%% Sets the height of suggestion list popup as number of lines +to show. Default is 16.&] +[s3;%% &] +[s4;%% &] +[s5;:SuggestCtrl`:`:Delimiter`(int`): [_^SuggestCtrl^ SuggestCtrl][@(0.0.255) `&]_[* Delimi +ter]([@(0.0.255) int]_[*@3 chr])&] +[s2;%% Sets list separator as character. Default is none, which means +text does not form a list.&] +[s3;%% &] +[s4;%% &] +[s5;:SuggestCtrl`:`:Delimiter`(int`(`*`)`(int c`)`): [_^SuggestCtrl^ SuggestCtrl][@(0.0.255) `& +]_[* Delimiter]([@(0.0.255) int]_(`*[*@3 filter])([@(0.0.255) int]_c))&] +[s2;%% Sets list separator as filter. Returning zero means character +is not list separator. Filter can alter the character (e.g. to +change `',`' to `';`') before it is written to the text.&] +[s3;%% &] +[s4;%% &] +[s5;:SuggestCtrl`:`:CompareFilter`(int`(`*`)`(int c`)`): [_^SuggestCtrl^ SuggestCtrl][@(0.0.255) `& +]_[* CompareFilter]([@(0.0.255) int]_(`*[*@3 filter])([@(0.0.255) int]_c))&] +[s2;%% Sets filter to be applied to text and to the suggestions before +it is compared while searching for suggestions.&] +[s0;%% ]] \ No newline at end of file diff --git a/uppsrc/plugin/jpg/init b/uppsrc/plugin/jpg/init index 9b1d10535..8d1bc5b2d 100644 --- a/uppsrc/plugin/jpg/init +++ b/uppsrc/plugin/jpg/init @@ -1,7 +1,7 @@ #ifndef _plugin_jpg_icpp_init_stub #define _plugin_jpg_icpp_init_stub #include "Draw/init" -#define BLITZ_INDEX__ Fd014d588c5c3282b5385cf46a1e5c56c +#define BLITZ_INDEX__ F227b3ee1134af92a2493f791a66e2afe #include "jpgreg.icpp" #undef BLITZ_INDEX__ #endif