mirror of
https://github.com/ultimatepp/ultimatepp.git
synced 2026-05-15 14:16:07 -06:00
bazaar: obsoleted DockCtrl moved to archive
git-svn-id: svn://ultimatepp.org/upp/trunk@3826 f0d560ea-af0d-0410-9eb7-867de7ffcac7
This commit is contained in:
cxl
parent
fc3fcdfe3f
commit
d38d643a74
22 changed files with 7331 additions and 0 deletions
226
archive/DockCtrl/AutoHideBar.cpp
Normal file
226
archive/DockCtrl/AutoHideBar.cpp
Normal file
|
|
@ -0,0 +1,226 @@
|
|||
#include "DockCtrl.h"
|
||||
|
||||
AutoHideBar& AutoHideBar::Attach(DockableCtrl& ctrl)
|
||||
{
|
||||
DockWindow& c = reinterpret_cast<DockWindow&>(ctrl);
|
||||
TabInterface::Add(c.SetOwnerBar(this));
|
||||
childcount++;
|
||||
ShowBar();
|
||||
active = -1;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void AutoHideBar::Detach(DockableCtrl& ctrl)
|
||||
{
|
||||
DockWindow& c = reinterpret_cast<DockWindow&>(ctrl);
|
||||
active = TabInterface::Find(ctrl);
|
||||
if(tabs.GetCount() == 1)
|
||||
{
|
||||
CloseAll();
|
||||
HideBar();
|
||||
}
|
||||
else Close(active);
|
||||
childcount--;
|
||||
c.SetOwnerBar(NULL);
|
||||
HideWindow();
|
||||
}
|
||||
|
||||
DockableCtrl* AutoHideBar::GetChild(int position)
|
||||
{
|
||||
int i = Find(position);
|
||||
if(i >= 0 && i < this->GetTabs().GetCount())
|
||||
return GetTabs().At(i).dock;
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int AutoHideBar::GetCount()
|
||||
{
|
||||
return childcount;
|
||||
}
|
||||
|
||||
void AutoHideBar::ShowWindow()
|
||||
{
|
||||
DockWindow* hiddenwindow = reinterpret_cast<DockWindow*>(tabs[active].dock);
|
||||
if(!hiddenwindow->IsOpen())
|
||||
{
|
||||
Size s = hiddenwindow->GetSizeHint();
|
||||
Rect r = GetScreenRect();
|
||||
Rect rr = r;
|
||||
switch(layout)
|
||||
{
|
||||
case LAYOUT_LEFT:
|
||||
rr.left = r.right;
|
||||
s.cy = r.GetHeight();
|
||||
#if defined(PLATFORM_X11)
|
||||
rr.right += 1;
|
||||
#endif
|
||||
break;
|
||||
case LAYOUT_TOP:
|
||||
rr.top = r.bottom;
|
||||
s.cx = r.GetWidth();
|
||||
#if defined(PLATFORM_X11)
|
||||
rr.bottom += 1;
|
||||
#endif
|
||||
break;
|
||||
case LAYOUT_RIGHT:
|
||||
rr.right = r.left;
|
||||
s.cy = r.GetHeight();
|
||||
#if defined(PLATFORM_X11)
|
||||
rr.left -= 1;
|
||||
#endif
|
||||
break;
|
||||
case LAYOUT_BOTTOM:
|
||||
rr.bottom = r.top;
|
||||
s.cx = r.GetWidth();
|
||||
#if defined(PLATFORM_X11)
|
||||
rr.top -= 1;
|
||||
#endif
|
||||
break;
|
||||
|
||||
}
|
||||
popup.SetRect(rr);
|
||||
popup.Add(hiddenwindow->SizePos());
|
||||
hiddenwindow->Ctrl::Show();
|
||||
popup.PopUp(GetOwner(), false, true, false, false);
|
||||
ctrl = hiddenwindow;
|
||||
Ctrl::ProcessEvents();
|
||||
AdjustSize(rr, s);
|
||||
Animate(popup, rr, GUIEFFECT_SLIDE);
|
||||
}
|
||||
}
|
||||
|
||||
void AutoHideBar::HideWindow()
|
||||
{
|
||||
if(popup.IsOpen())
|
||||
popup.Close();
|
||||
if(ctrl)
|
||||
{
|
||||
if(ctrl->IsChild())
|
||||
ctrl->Remove();
|
||||
ctrl = NULL;
|
||||
}
|
||||
active = -1;
|
||||
highlight = -1;
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void AutoHideBar::AdjustSize(Rect &r, const Size &sz)
|
||||
{
|
||||
switch (layout)
|
||||
{
|
||||
case LAYOUT_LEFT:
|
||||
r.right += sz.cx;
|
||||
break;
|
||||
case LAYOUT_TOP:
|
||||
r.bottom += sz.cy;
|
||||
break;
|
||||
case LAYOUT_RIGHT:
|
||||
r.left -= sz.cx;
|
||||
break;
|
||||
case LAYOUT_BOTTOM:
|
||||
r.top -= sz.cy;
|
||||
break;
|
||||
};
|
||||
}
|
||||
|
||||
void AutoHideBar::OnHighlight()
|
||||
{
|
||||
DockableCtrl* hiddenwindow = NULL;
|
||||
|
||||
if(highlight >= 0)
|
||||
hiddenwindow = tabs[highlight].dock;
|
||||
if(!hiddenwindow || hiddenwindow == ctrl)
|
||||
return;
|
||||
else if(ctrl)
|
||||
{
|
||||
if(hiddenwindow)
|
||||
{
|
||||
if(popup.IsOpen())
|
||||
popup.Close();
|
||||
ctrl->Remove();
|
||||
ctrl = NULL;
|
||||
}
|
||||
else HideWindow();
|
||||
}
|
||||
if(hiddenwindow)
|
||||
{
|
||||
TabInterface::SetActiveTab(highlight);
|
||||
ShowWindow();
|
||||
}
|
||||
}
|
||||
|
||||
void AutoHideBar::OnClose(int id, DockableCtrl& ctrl)
|
||||
{
|
||||
ctrl.Shut();
|
||||
}
|
||||
|
||||
void AutoHideBar::MouseMove(Point p, dword keysflags)
|
||||
{
|
||||
TabInterface::MouseMove(p, keysflags);
|
||||
}
|
||||
|
||||
void AutoHideBar::MouseEnter(Point p, dword keyflags)
|
||||
{
|
||||
if (ctrl && ctrl->IsOpen()) KillTimeCallback(2);
|
||||
TabInterface::MouseEnter(p, keyflags);
|
||||
}
|
||||
|
||||
void AutoHideBar::MouseLeave()
|
||||
{
|
||||
if (ctrl && ctrl->IsOpen())
|
||||
KillSetTimeCallback(1000, THISBACK(HideWindow), 2);
|
||||
TabInterface::MouseLeave();
|
||||
}
|
||||
|
||||
void AutoHideBar::FrameAdd(Ctrl& parent)
|
||||
{
|
||||
parent.Add(*this);
|
||||
}
|
||||
|
||||
void AutoHideBar::FrameRemove()
|
||||
{
|
||||
this->Ctrl::Remove();
|
||||
}
|
||||
|
||||
void AutoHideBar::ShowBar()
|
||||
{
|
||||
if(!size) SetSize(GetHeight() + 2);
|
||||
}
|
||||
|
||||
void AutoHideBar::HideBar()
|
||||
{
|
||||
if(size) SetSize(0);
|
||||
}
|
||||
|
||||
AutoHideBar::AutoHideBar()
|
||||
{
|
||||
internalname = "autohidebar";
|
||||
ctrl = NULL;
|
||||
SetStyle(DockCtrlChStyle::StyleDefault());
|
||||
HasScrollBar(false);
|
||||
HasButtons(false);
|
||||
HasIcons(true);
|
||||
Draggable(false);
|
||||
SetSize(0);
|
||||
childcount = 0;
|
||||
|
||||
TabInterface::WhenHighlight = THISBACK(OnHighlight);
|
||||
TabInterface::WhenClose = THISBACK(OnClose);
|
||||
|
||||
popup.WhenEnter = THISBACK2(MouseEnter, Point(0, 0), 0);
|
||||
popup.WhenLeave = THISBACK(MouseLeave);
|
||||
}
|
||||
|
||||
AutoHideBar::~AutoHideBar()
|
||||
{
|
||||
ctrl = NULL;
|
||||
}
|
||||
|
||||
void AutoHideBar::PopupWindow::ChildMouseEvent(Ctrl *child, int event, Point p, int zdelta, dword keyflags)
|
||||
{
|
||||
if(event == MOUSELEAVE)
|
||||
WhenLeave();
|
||||
else if(event == MOUSEENTER)
|
||||
WhenEnter();
|
||||
Ctrl::ChildMouseEvent(child, event, p, zdelta, keyflags);
|
||||
}
|
||||
115
archive/DockCtrl/ChangeLog.txt
Normal file
115
archive/DockCtrl/ChangeLog.txt
Normal file
|
|
@ -0,0 +1,115 @@
|
|||
//==============================================================================================
|
||||
// DockCtrl: A dockable widget framework for U++
|
||||
// Author: Ismail YILMAZ
|
||||
//==============================================================================================
|
||||
|
||||
|
||||
[+] - new feature
|
||||
[-] - bugfix
|
||||
[*] - change
|
||||
|
||||
Recent revisions are added to the current versions logs under date/time info.
|
||||
|
||||
0.50
|
||||
> First Public Beta - public release name DockCtrl DEV802b.1
|
||||
> Package versioning is synchronised with the main Ultimate++ releases.
|
||||
--------------------------------------------------------------------------------------------
|
||||
+ full featured tabbed dock windows implemented.
|
||||
optional "Nested tabbing" (a complex, yet very easy to use tabbing mode) introduced.
|
||||
automatic tab alignment of tabbed windows is made optional.
|
||||
+ autohide feature is implemented.
|
||||
"tabbed autohiding" introduced.
|
||||
animated window (Thanks to Mrjtuk).
|
||||
+ introducing "Complex Dockable Framework" concept. namely, numereous and seperate
|
||||
DockCtrl can be nested in any standard U++ Ctrl derived class.
|
||||
+ unified (mostly...) Chameleon structure "DockCtrlChStyle" added for easy customization.
|
||||
+ internationalization support added. currentyl only Turkish and English languages are supported.
|
||||
+ added settings menu
|
||||
+ added SetLayout() method for easy instatiation of DockCtrl class.
|
||||
+ self-explanatory example code is added to the package.
|
||||
* DockPane helper class renamed to PaneFrame;
|
||||
* removed Splitter ctrl code from DockPane and made into a seperate custom class PaneSplitter.
|
||||
* control panel is heavily improved.
|
||||
from now on, control panel has full access and control over the docked windows.
|
||||
- Fixed most of the sizing issues by adding size hint methods (see DockableCtrl.cpp).
|
||||
- Many internal bugfix and cleanup.
|
||||
|
||||
0.51
|
||||
> public release name DockCtrl DEV802b.2
|
||||
--------------------------------------------------------------------------------------------
|
||||
2/19/2008
|
||||
- fixed a nasty bug in TabWindow Detach() method which led to stack overflow error.
|
||||
(However, this feature is still in it'a alpha stage. So, it is experimental. There may very well
|
||||
be bugs... USE IT AT YOUR RISK!)
|
||||
- fixed tab dragging bug which cause to trigger the StartWindowDrag() in tab frame's empty area.
|
||||
- ResetLayout() method fixed and renamed to ResetWidgetLayout().
|
||||
- the tabs and tabbed window title showed incorrect info(title, icon) in "nested tabbing" mode
|
||||
and in "tabbed autohide" mede. this bug is fixed for both mode by adding
|
||||
RefreshTabWindowLabel() method to TabWindow class.
|
||||
- other internal and minor bugfixes.
|
||||
* removed irrelevant packages from the assembly :) (remnants of my early experiments...)
|
||||
* DockCtrlExample is added to the package. now the main package is named DockCtrl Dev802b.2
|
||||
* default and enhanced background skins are polished. now they have more native look.
|
||||
|
||||
2/20/2008
|
||||
+ german translation added (Thanks to Masu).
|
||||
- fixed "call by reference errors" under MingW 3.4.2 (Thanks to Masu)
|
||||
- Tab text alignment, close button detection bugs and scrollbar separator line painting are fixed (Thank to Unodgs).
|
||||
- fixed autohide bug which caused the framework fall into an infinite loop when trying to hide a 2+ level nested tabs.
|
||||
|
||||
2/21/2008
|
||||
* from now on, default U++ chameleon skins are used for painting the dragbar background (in default and enhanced style)
|
||||
namely, from now on system colors applies to the Dockctrl dragbar. used skin samples are as following:
|
||||
default skin = drawed using default TabCtrl style.
|
||||
enhanced skin = drawed using default ToolBar style.
|
||||
classic skin = no special draw action (uses current system background).
|
||||
+ tab repositioning for TabWindow and Autohide (using Ctrl + Left drag or with solely Middle Drag) added;
|
||||
|
||||
2/23/2008
|
||||
+ added partial X11 support (only drag-n-drop at the moment) - thanks to Mrjtuk.
|
||||
* from now on, tab drag-n-drop animation has transparency effect.
|
||||
- fixed a bug in tab animation which causes to set the active tab to the last tab in the list. now the tabs
|
||||
correctly set the cursour to the previously active tab if the dnd is cancelled.
|
||||
- fixed a bug in tab animation transparency effect which causes pane's with more than 2 childs to draw the animation
|
||||
incorrectly.
|
||||
- Fixed a nasty bug in AlphaHighlight() function to crash the application when compiled under MingW (5.1.3) (Thanks to Masu)
|
||||
|
||||
2/26/2008
|
||||
+ X11 related dnd issues fixed. DockCtrl now has full X11 docking support (Tested On KUBUNTU).
|
||||
+ Russian translation and more accurate layout file for control panel added to the source (Thanks to Anton).
|
||||
|
||||
0.52
|
||||
> public release name DockCtrl DEV803b.1
|
||||
--------------------------------------------------------------------------------------------
|
||||
3/21/2008
|
||||
+ added full serialization support.
|
||||
+ added default/custom layout support.
|
||||
* DockableCtrl class reworked (now it is more abstract);
|
||||
* TabWindow class reworked (no longer uses PaneSplitter() class to control child widgets).
|
||||
* DockCtrl class renamed to DockBase class and added a more generic DockCtrl class.
|
||||
* DockBase class derives from TopWindow.
|
||||
+ added InitDockCtrl() method for widget initialization.
|
||||
+ added InitCustomLayouts() method for planned "predefined" layout support.
|
||||
+ added Tabify() method (with 1 overload) to simplify widget tabbing.
|
||||
+ added DockFloat() method to DockableCtrl class.
|
||||
+ added ShowDragBarButtons() method to DockWindow class.
|
||||
+ added ForbidDragAndDrop()/PermitDragAndDrop() methods to DockableCtrl base widget class.
|
||||
dnd behaviour of each DockableCtrl derived widget can be controlled using this method pair.
|
||||
+ added layout group to the settings window.
|
||||
+ added HotKey support for Settings window (default is CTRL + HOME).
|
||||
+ added methods to control forbid/permit on window sides.
|
||||
- numerous bugfixes, and improvements.
|
||||
|
||||
3/22/2008
|
||||
+ double clicking on a dragbar of a authidden dockwindow will cause it go into docked state.
|
||||
+ added "stdsize" variable to the PaneFrame class.
|
||||
+ added ShowXXXXPane() (X:left/top/right/bottom) public methods to the Dockbase class.
|
||||
|
||||
3/27/2008
|
||||
+ added widget grouping (both predefined/default and user) support.
|
||||
+ added WidgetGroup() method and defined "%" operator for widget grouping.
|
||||
+ added group manager to the settings window.
|
||||
* tab window creation/managment mechanism changed.
|
||||
|
||||
|
||||
|
||||
1419
archive/DockCtrl/DockCtrl.cpp
Normal file
1419
archive/DockCtrl/DockCtrl.cpp
Normal file
File diff suppressed because it is too large
Load diff
1135
archive/DockCtrl/DockCtrl.h
Normal file
1135
archive/DockCtrl/DockCtrl.h
Normal file
File diff suppressed because it is too large
Load diff
31
archive/DockCtrl/DockCtrl.lay
Normal file
31
archive/DockCtrl/DockCtrl.lay
Normal file
|
|
@ -0,0 +1,31 @@
|
|||
LAYOUT(ControlPanelLayout, 444, 480)
|
||||
ITEM(StaticText, dv___0, SetText(t_("Select skin:")).SetAlign(ALIGN_CENTER).LeftPosZ(8, 168).TopPosZ(8, 22))
|
||||
ITEM(Button, layoutbutton, SetLabel(t_("Reset")).Tip(t_("Press to reset window layout.")).LeftPosZ(16, 82).BottomPosZ(18, 22))
|
||||
ITEM(Button, layoutadd, SetLabel(t_("Add")).RightPosZ(80, 56).BottomPosZ(18, 22))
|
||||
ITEM(Option, TabOptionIcon, SetLabel(t_("Show Icons")).LeftPosZ(20, 188).TopPosZ(64, 16))
|
||||
ITEM(Option, TabOptionClose, SetLabel(t_("Show Buttons")).LeftPosZ(20, 188).TopPosZ(84, 16))
|
||||
ITEM(Option, AutoOptionClose, SetLabel(t_("Show Buttons")).HSizePosZ(240, 16).TopPosZ(84, 16))
|
||||
ITEM(Option, AutoOptionIcon, SetLabel(t_("Show Icons")).HSizePosZ(240, 16).TopPosZ(64, 16))
|
||||
ITEM(DropList, skinlist, HSizePosZ(192, 8).TopPosZ(8, 22))
|
||||
ITEM(LabelBox, TabOptions, SetLabel(t_("Tab Options")).LeftPosZ(8, 208).TopPosZ(44, 108))
|
||||
ITEM(Option, TabOptionNest, SetLabel(t_("Allow Nested Tabs")).LeftPosZ(20, 188).TopPosZ(124, 16))
|
||||
ITEM(Option, TabOptionAlignment, SetLabel(t_("Auto Align Tabs")).LeftPosZ(20, 188).TopPosZ(104, 16))
|
||||
ITEM(LabelBox, AutoOptions, SetLabel(t_("AutoHide Options")).HSizePosZ(228, 8).TopPosZ(44, 108))
|
||||
ITEM(LabelBox, dv___12, SetLabel(t_("Layout Settings")).HSizePosZ(8, 8).BottomPosZ(8, 52))
|
||||
ITEM(DropList, layoutlist, HSizePosZ(104, 148).BottomPosZ(18, 22))
|
||||
ITEM(Button, layoutdelete, SetLabel(t_("Delete")).RightPosZ(16, 56).BottomPosZ(18, 22))
|
||||
ITEM(TabCtrl, panel, HSizePosZ(8, 8).VSizePosZ(160, 72))
|
||||
END_LAYOUT
|
||||
|
||||
LAYOUT(WidgetListLayout, 376, 236)
|
||||
ITEM(ArrayCtrl, list, HorzGrid(false).VertGrid(false).AskRemove(false).AutoHideSb(true).SetFrame(FieldFrame()).HSizePosZ(10, 10).VSizePosZ(48, 12))
|
||||
ITEM(Label, dv___1, SetLabel(t_("Below are the available dockable window.\nLeft clicking on the items will popup the action menu for the selected item.")).HSizePosZ(10, 10).TopPosZ(8, 36))
|
||||
END_LAYOUT
|
||||
|
||||
LAYOUT(WidgetGroupsLayout, 404, 300)
|
||||
ITEM(TreeCtrl, grouptree, HSizePosZ(8, 8).VSizePosZ(44, 4))
|
||||
ITEM(Button, groupdelete, SetLabel(t_("Delete")).RightPosZ(8, 56).TopPosZ(12, 22))
|
||||
ITEM(Button, groupadd, SetLabel(t_("Add")).RightPosZ(76, 56).TopPosZ(12, 22))
|
||||
ITEM(Label, dv___3, SetLabel(t_("You can use Drag/Drop to change Widget groups.\nRight click on groups/items for action menu. ")).HSizePosZ(8, 144).TopPosZ(7, 32))
|
||||
END_LAYOUT
|
||||
|
||||
999
archive/DockCtrl/DockCtrl.t
Normal file
999
archive/DockCtrl/DockCtrl.t
Normal file
|
|
@ -0,0 +1,999 @@
|
|||
#ifdef _MSC_VER
|
||||
#pragma setlocale("C")
|
||||
#endif
|
||||
// DockCtrl.cpp
|
||||
|
||||
T_("LEFT")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("LINKS")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("ЛЕВАЯ ГРАНИЦА")
|
||||
srSP("")
|
||||
trTR("SOL")
|
||||
|
||||
T_("TOP")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("OBEN")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("ВЕРХНЯЯ ГРАНИЦА")
|
||||
srSP("")
|
||||
trTR("ÜST")
|
||||
|
||||
T_("RIGHT")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("RECHTS")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("ПРАВАЯ ГРАНИЦА")
|
||||
srSP("")
|
||||
trTR("SAĞ")
|
||||
|
||||
T_("BOTTOM")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("UNTEN")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("НИЖНЯЯ ГРАНИЦА")
|
||||
srSP("")
|
||||
trTR("ALT")
|
||||
|
||||
T_("FLOATING")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("GLEITEND")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("ОТДЕЛЕНО")
|
||||
srSP("")
|
||||
trTR("BAĞIMSIZ")
|
||||
|
||||
T_("NONE")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("LEER")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("НИ ОДИН")
|
||||
srSP("")
|
||||
trTR("YOK")
|
||||
|
||||
T_("SHOWN")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("SICHTBAR")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("ОТОБРАЖЕНО")
|
||||
srSP("")
|
||||
trTR("GÖRÜNÜR")
|
||||
|
||||
T_("HIDDEN")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("VERSTECKT")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("СКРЫТО")
|
||||
srSP("")
|
||||
trTR("GİZLİ")
|
||||
|
||||
T_("AUTO HIDDEN")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("AUTOMATISCH VERSTECKEN")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("АВТОСКРЫТИЕ")
|
||||
srSP("")
|
||||
trTR("OTOMATİK GİZLİ")
|
||||
|
||||
T_("SHUT")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("GESCHLOSSEN")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("ЗАКРЫТО")
|
||||
srSP("")
|
||||
trTR("KAPALI")
|
||||
|
||||
T_("TABBED")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("REGISTERKARTE")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("ВЛОЖЕНО")
|
||||
srSP("")
|
||||
trTR("SEKMELİ")
|
||||
|
||||
T_("Default")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("Základní")
|
||||
deDE("Voreinstellung")
|
||||
esES("Por defecto")
|
||||
fiFI("Oletus")
|
||||
frFR("Par défaut")
|
||||
huHU("Alapértelmezett")
|
||||
ruRU("По умолчанию")
|
||||
srSP("Podrazumevano")
|
||||
trTR("Varsayılan")
|
||||
|
||||
T_("Settings")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Einstellungen")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Настройки")
|
||||
srSP("")
|
||||
trTR("Ayarlar")
|
||||
|
||||
T_("Window Title")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Fenstername")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Заголовок окна")
|
||||
srSP("")
|
||||
trTR("Pencere Başlığı")
|
||||
|
||||
T_("Alignment")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("&Zarovnat:")
|
||||
deDE("Ausrichtung")
|
||||
esES("")
|
||||
fiFI("Kohdistus")
|
||||
frFR("Alignement")
|
||||
huHU("Igazítás")
|
||||
ruRU("Выравнивание")
|
||||
srSP("Poravnanje:")
|
||||
trTR("Kenar")
|
||||
|
||||
T_("State")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Status")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Статус")
|
||||
srSP("")
|
||||
trTR("Durum")
|
||||
|
||||
T_("Position")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Position")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Позиция")
|
||||
srSP("")
|
||||
trTR("Konum")
|
||||
|
||||
T_("Status")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Durum")
|
||||
|
||||
T_("Group Manager")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Grup Yöneticisi")
|
||||
|
||||
T_("Classic")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Klassisch")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Классический")
|
||||
srSP("")
|
||||
trTR("Klasik")
|
||||
|
||||
T_("Enhanced")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Erweitert")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Расширенный")
|
||||
srSP("")
|
||||
trTR("Gelişmiş")
|
||||
|
||||
T_("Add new layout")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Сохранить размещение")
|
||||
srSP("")
|
||||
trTR("Pencere Düzeni ekle")
|
||||
|
||||
T_("Layout name:")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Pencere düzeni adı:")
|
||||
|
||||
T_("You must enter a name for the new layout")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Вы должны ввести имя для нового размещения")
|
||||
srSP("")
|
||||
trTR("Yeni pencere düzeni için bir isim girmelisiniz")
|
||||
|
||||
T_("Layout '%s' adready exists. Do you want to overwrite it?")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Размещение '%s' уже существует. Переписать?")
|
||||
srSP("")
|
||||
trTR("'%s' adında pencere düzeni mevcut. Üzerine yazmak ister misiniz?")
|
||||
|
||||
T_("Do you really want to delete layout '%s'?")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("'%s' adlı pencere düzenini gerçekten silmek istiyor musunuz?")
|
||||
|
||||
T_("Error: Widget (%s) is already in the group '%s'.")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Hata: Widget (%s) zaten '%s' grubunun içinde var.")
|
||||
|
||||
T_("Do you really want to delete group '%s'")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Gerçekten '%s' grubunu silmek istiyor musunuz?")
|
||||
|
||||
T_("Add new group")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Yeni grup ekle")
|
||||
|
||||
T_("Group name:")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Grup adı:")
|
||||
|
||||
T_("You must enter a name for the new group")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Yeni grup için bir grup adı girmelisiniz")
|
||||
|
||||
T_("Group '%s' adready exists. Do you want to overwrite it?")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("'%s' grubu zaten mevcut. Üzerine yazmak ister misiniz?")
|
||||
|
||||
T_("Available Widget Groups")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Mevcut Widget Grupları")
|
||||
|
||||
T_("Dock Group '%s'")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("'%s' Grubunu Yasla")
|
||||
|
||||
T_("AutoHide Group '%s'")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("'%s' Grubunu Otomatik Gizle")
|
||||
|
||||
T_("Float Group '%s'")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("'%s' Grubunu Kaydır")
|
||||
|
||||
T_("Tabify Group '%s' and...")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("'%s' Grubunu Sekmeli Yap ve...")
|
||||
|
||||
T_("Delete Group '%s'")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("'%s' Grubunu Sil")
|
||||
|
||||
T_("Close Group '%s'")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("'%s' Grubunu Kapat")
|
||||
|
||||
T_("Add New Group...")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Yeni Grup Ekle...")
|
||||
|
||||
T_("Top")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("Nahoře")
|
||||
deDE("Oben")
|
||||
esES("")
|
||||
fiFI("Ylä")
|
||||
frFR("Haut")
|
||||
huHU("Felső szél")
|
||||
ruRU("Верх")
|
||||
srSP("Vrh")
|
||||
trTR("Üst")
|
||||
|
||||
T_("Left")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("Vlevo")
|
||||
deDE("Links")
|
||||
esES("")
|
||||
fiFI("Vasen")
|
||||
frFR("Gauche")
|
||||
huHU("Bal")
|
||||
ruRU("Влево")
|
||||
srSP("Levo")
|
||||
trTR("Sol")
|
||||
|
||||
T_("Right")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("Vpravo")
|
||||
deDE("Rechts")
|
||||
esES("")
|
||||
fiFI("Oikea")
|
||||
frFR("Droite")
|
||||
huHU("Jobb")
|
||||
ruRU("Вправо")
|
||||
srSP("Desno")
|
||||
trTR("Sağ")
|
||||
|
||||
T_("Bottom")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("Dole")
|
||||
deDE("Unten")
|
||||
esES("")
|
||||
fiFI("Ala")
|
||||
frFR("Base")
|
||||
huHU("Alsó szél")
|
||||
ruRU("Низ")
|
||||
srSP("Dno")
|
||||
trTR("Alt")
|
||||
|
||||
T_("Dock")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Einratsen")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Разместить")
|
||||
srSP("")
|
||||
trTR("Yasla")
|
||||
|
||||
T_("Auto Hide")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Automatisch verstecken")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Автоскрытие")
|
||||
srSP("")
|
||||
trTR("Otomatik Gizle")
|
||||
|
||||
T_("Float")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Gleiten")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Отделить")
|
||||
srSP("")
|
||||
trTR("Kaydır")
|
||||
|
||||
|
||||
// DockTabs.cpp
|
||||
|
||||
T_("")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("")
|
||||
|
||||
T_("Untitled")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Ohne Namen")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Безымянный")
|
||||
srSP("")
|
||||
trTR("Adsız")
|
||||
|
||||
|
||||
// DockWindow.cpp
|
||||
|
||||
T_("Close")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("Zavřít")
|
||||
deDE("Schließen")
|
||||
esES("Cerra")
|
||||
fiFI("Sulje")
|
||||
frFR("Fermer")
|
||||
huHU("Bezár")
|
||||
ruRU("Закрыть")
|
||||
srSP("Zatvori")
|
||||
trTR("Kapat")
|
||||
|
||||
T_("Auto Hide")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Automatisch verstecken")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Автоскрытие")
|
||||
srSP("")
|
||||
trTR("Otomatik Gizle")
|
||||
|
||||
T_("Window Position")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Fensterposition")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Позиция окна")
|
||||
srSP("")
|
||||
trTR("Pencere Konumu")
|
||||
|
||||
T_("Show")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Zeigen")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Показать")
|
||||
srSP("")
|
||||
trTR("Göster")
|
||||
|
||||
T_("Hide")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Verstecken")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Скрыть")
|
||||
srSP("")
|
||||
trTR("Gizle")
|
||||
|
||||
T_("Tabbed Window")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Registerkartenfenster")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Окно со вкладками")
|
||||
srSP("")
|
||||
trTR("Yeni Sekme")
|
||||
|
||||
|
||||
// DockCtrl.lay
|
||||
|
||||
T_("Select skin:")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Wählen Sie das Erscheinungsbild:")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Выбрать оформление:")
|
||||
srSP("")
|
||||
trTR("Kaplama:")
|
||||
|
||||
T_("Reset")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("Nulovat")
|
||||
deDE("Zurücksetzen")
|
||||
esES("")
|
||||
fiFI("Resetoi")
|
||||
frFR("Réinitialiser")
|
||||
huHU("Kiinduló állapot")
|
||||
ruRU("Сбросить")
|
||||
srSP("Vrati")
|
||||
trTR("Sıfırla")
|
||||
|
||||
T_("Press to reset window layout.")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Bitte betätigen, um Fensteranordnung zurückzusetzen.")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Нажмите для сброса положения элементов.")
|
||||
srSP("")
|
||||
trTR("Pencere düzenini sıfırlamak için tıklayın")
|
||||
|
||||
T_("Add")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Ekle")
|
||||
|
||||
T_("Show Icons")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Zeige Icons")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Показывать иконки")
|
||||
srSP("")
|
||||
trTR("Simgeleri Göster")
|
||||
|
||||
T_("Show Buttons")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Zeige Buttons")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Показывать кнопки")
|
||||
srSP("")
|
||||
trTR("Düğmeleri Göster")
|
||||
|
||||
T_("Tab Options")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Registerkertenoptionen")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Опции вкладок")
|
||||
srSP("")
|
||||
trTR("Sekmeli Pencere Seçenekleri")
|
||||
|
||||
T_("Allow Nested Tabs")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("Erlaube verschachtelte Registerkarten")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Разрешить вкладки")
|
||||
srSP("")
|
||||
trTR("İçiçe Sekmelere İzin Ver")
|
||||
|
||||
T_("Auto Align Tabs")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Sekmeleri Otomatik Düzenle")
|
||||
|
||||
T_("Auto Hide Options")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Otomatik Gizleme Seçenekleri")
|
||||
|
||||
T_("Layout Settings")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Pencere Düzeni Ayarları")
|
||||
|
||||
T_("Delete")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Sil")
|
||||
|
||||
T_("Below are the available dockable window.\nLeft clicking on the items will "
|
||||
"popup the action menu for the selected item.")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Mevcut yaslanabilir pencereler aşağıdadır.\nİşlemler menüsüne ulaşmak için "
|
||||
"istediğiniz öğenin üzerine sol tıklayın.")
|
||||
|
||||
T_("You can use Drag/Drop to change Widget groups.\nRight click on groups/items "
|
||||
"for action menu. ")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("")
|
||||
srSP("")
|
||||
trTR("Widget gruplarını değiştirmek için Sürükle/Bırak yapabilirsiniz.")
|
||||
|
||||
|
||||
// Obsolete
|
||||
|
||||
T_("Do you really want to delete layout '%s' ?")
|
||||
afZA("")
|
||||
beBY("")
|
||||
bgBG("")
|
||||
csCZ("")
|
||||
deDE("")
|
||||
esES("")
|
||||
fiFI("")
|
||||
frFR("")
|
||||
huHU("")
|
||||
ruRU("Удалить размещение '%s' ?")
|
||||
srSP("")
|
||||
trTR("'%s' adlı pencere düzenini gerçekten silmek istiyor musunuz?")
|
||||
30
archive/DockCtrl/DockCtrl.upp
Normal file
30
archive/DockCtrl/DockCtrl.upp
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
description "Dockable/dynamic widget framework by İsmail Yılmaz";
|
||||
|
||||
uses
|
||||
CtrlCore,
|
||||
CtrlLib,
|
||||
Draw;
|
||||
|
||||
file
|
||||
READMEFIRST.txt,
|
||||
"Header Files" readonly separator,
|
||||
DockCtrl.h,
|
||||
"Source Files" readonly separator,
|
||||
AutoHideBar.cpp,
|
||||
PaneSplitter.cpp,
|
||||
PaneFrame.cpp,
|
||||
DockCtrl.cpp charset "UTF-8",
|
||||
DockTabs.cpp,
|
||||
DockWindow.cpp,
|
||||
DockableCtrl.cpp,
|
||||
Resources readonly separator,
|
||||
DockableCtrl.iml,
|
||||
DockCtrl.lay,
|
||||
DockCtrl.t charset "UTF-8",
|
||||
"Other Files" readonly separator,
|
||||
TODO.txt,
|
||||
ChangeLog.txt;
|
||||
|
||||
mainconfig
|
||||
"" = "GUI";
|
||||
|
||||
890
archive/DockCtrl/DockTabs.cpp
Normal file
890
archive/DockCtrl/DockTabs.cpp
Normal file
|
|
@ -0,0 +1,890 @@
|
|||
#include "DockCtrl/DockCtrl.h"
|
||||
|
||||
#define IMAGECLASS DockCtrlImgs
|
||||
#define IMAGEFILE <DockCtrl/DockableCtrl.iml>
|
||||
#include <Draw/iml_source.h>
|
||||
|
||||
|
||||
void DockCtrlCustomFrame::FrameLayout(Rect& r)
|
||||
{
|
||||
switch(layout)
|
||||
{
|
||||
case LAYOUT_LEFT:
|
||||
LayoutFrameLeft(r, this, size);
|
||||
break;
|
||||
case LAYOUT_TOP:
|
||||
LayoutFrameTop(r, this, size);
|
||||
break;
|
||||
case LAYOUT_RIGHT:
|
||||
LayoutFrameRight(r, this, size);
|
||||
break;
|
||||
case LAYOUT_BOTTOM:
|
||||
LayoutFrameBottom(r, this, size);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void DockCtrlCustomFrame::FrameAddSize(Size& sz)
|
||||
{
|
||||
switch(layout)
|
||||
{
|
||||
case LAYOUT_LEFT:
|
||||
sz.cx += size;
|
||||
break;
|
||||
case LAYOUT_TOP:
|
||||
sz.cy += size;
|
||||
break;
|
||||
case LAYOUT_RIGHT:
|
||||
sz.cx += size;
|
||||
break;
|
||||
case LAYOUT_BOTTOM:
|
||||
sz.cy += size;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
DockCtrlCustomFrame& DockCtrlCustomFrame::SetStyle(const DockCtrlChStyle::Style& s)
|
||||
{
|
||||
style = &s;
|
||||
return *this;
|
||||
}
|
||||
|
||||
const DockCtrlChStyle::Style* DockCtrlCustomFrame::GetStyle()
|
||||
{
|
||||
return style ? style : &DockCtrlChStyle::StyleDefault();
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------------------------
|
||||
|
||||
void TabInterface::Add(String name, bool activate)
|
||||
{
|
||||
Tab &t = tabs.Add();
|
||||
if(IsNull(name) || name == t_("")) name = t_("Untitled");
|
||||
else t.name = name;
|
||||
t.id = GetNextId();
|
||||
t.active = activate;
|
||||
t.visible = true;
|
||||
t.highlighted = false;
|
||||
t.icon = DockCtrlImgs::DefaultImage();
|
||||
ReposTabs();
|
||||
SetActiveTab(tabs.GetCount() - 1);
|
||||
}
|
||||
|
||||
void TabInterface::Add(DockableCtrl& dock, bool activate)
|
||||
{
|
||||
Tab &t = tabs.Add();
|
||||
if(dock.GetLabel().IsVoid() || dock.GetLabel() == t_("")) t.name = t_("Untitled");
|
||||
else t.name = dock.GetLabel();
|
||||
t.id = GetNextId();
|
||||
t.active = activate;
|
||||
t.visible = true;
|
||||
t.highlighted = false;
|
||||
t.icon = dock.GetIcon();
|
||||
t.dock = &dock;
|
||||
ReposTabs();
|
||||
SetActiveTab(tabs.GetCount() - 1);
|
||||
}
|
||||
|
||||
void TabInterface::Remove(DockableCtrl& dock)
|
||||
{
|
||||
}
|
||||
|
||||
void TabInterface::Remove(int n)
|
||||
{
|
||||
}
|
||||
|
||||
void TabInterface::Close(int n)
|
||||
{
|
||||
if(tabs.GetCount() < 1 || n >= tabs.GetCount()) // !!!
|
||||
return;
|
||||
int c = Find(tabs[n].id);
|
||||
int nc = GetNext(c);
|
||||
if(nc < 0)
|
||||
nc = max(0, GetPrev(c));
|
||||
|
||||
if(hasscrollbar) scrollbar.AddTotal(-tabs[n].cx);
|
||||
tabs.Remove(n);
|
||||
ReposTabs();
|
||||
SetActiveTab(nc);
|
||||
}
|
||||
|
||||
void TabInterface::CloseAll()
|
||||
{
|
||||
for(int i = tabs.GetCount() - 1; i >= 0; i--)
|
||||
{
|
||||
tabs.At(i).dock = NULL;
|
||||
tabs.At(i).id = -1;
|
||||
tabs.Remove(i);
|
||||
}
|
||||
if(hasscrollbar) scrollbar.SetTotal(0);//scrollbar.SetTotal(tabs[0].cx);
|
||||
ReposTabs();
|
||||
SetActiveTab(-1);
|
||||
id = -1;
|
||||
}
|
||||
|
||||
void TabInterface::SetActiveTab(int n)
|
||||
{
|
||||
int tabcount = tabs.GetCount();
|
||||
|
||||
if(tabcount == 0)
|
||||
return;
|
||||
|
||||
if(n < 0 || n >= tabcount)
|
||||
n = max(0, tabcount - 1);
|
||||
|
||||
Tab& t = tabs[active = n];
|
||||
int cx = t.x - (int(hasscrollbar) * scrollbar.GetPos());
|
||||
if(hasscrollbar)
|
||||
{
|
||||
if(cx < 0)
|
||||
scrollbar.AddPos(cx - 10);
|
||||
else
|
||||
{
|
||||
cx = t.x + t.cx - GetSize().cx - scrollbar.GetPos();
|
||||
if(cx > 0)
|
||||
scrollbar.AddPos(cx + 10);
|
||||
}
|
||||
}
|
||||
if(HasMouse())MouseMove(GetMouseViewPos(), 0);
|
||||
UpdateActionRefresh();
|
||||
WhenSelect();
|
||||
}
|
||||
|
||||
void TabInterface::SetActiveTab(DockableCtrl& dock)
|
||||
{
|
||||
SetActiveTab(Find(dock));
|
||||
}
|
||||
|
||||
void TabInterface::SetActiveTabTitle(String name, Image icon)
|
||||
{
|
||||
if(active < 0) return;
|
||||
Tab& t = tabs.At(active);
|
||||
t.name = name;
|
||||
t.icon = icon;
|
||||
ReposTabs();
|
||||
}
|
||||
|
||||
TabInterface& TabInterface::HasScrollBar(bool b)
|
||||
{
|
||||
if(b)
|
||||
{
|
||||
AddFrame(scrollbar);
|
||||
scrollbar.WhenScroll = THISBACK(OnScrollBar);
|
||||
}
|
||||
else
|
||||
RemoveFrame(scrollbar);
|
||||
Refresh();
|
||||
hasscrollbar = b;
|
||||
return *this;
|
||||
}
|
||||
|
||||
int TabInterface::GetActiveTab()
|
||||
{
|
||||
return active;
|
||||
}
|
||||
|
||||
int TabInterface::Find(int itemid)
|
||||
{
|
||||
for(int i = 0; i < tabs.GetCount(); i++)
|
||||
if(tabs[i].id == itemid) return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
int TabInterface::Find(DockableCtrl& dock)
|
||||
{
|
||||
for(int i = 0; i < tabs.GetCount(); i++)
|
||||
if(tabs[i].dock == &dock) return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
int TabInterface::GetNext(int n)
|
||||
{
|
||||
for(int i = n + 1; i < tabs.GetCount(); i++)
|
||||
if(tabs[i].visible) return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
int TabInterface::GetPrev(int n)
|
||||
{
|
||||
for(int i = n - 1; i >= 0; i--)
|
||||
if(tabs[i].visible) return i;
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
||||
int TabInterface::GetWidth(int n)
|
||||
{
|
||||
Tab &t = tabs[n];
|
||||
t.textsize = GetTextSize(t.name, style->font);
|
||||
return TAB_MARGIN * 2 + t.textsize.cx + ((hasfileicon ? TAB_SPACE : TAB_SPACE / 2) + DockCtrlImgs::DClose().GetSize().cx) * hastabbutton + (TAB_FILEICON + TAB_SPACEICON) * hasfileicon;
|
||||
}
|
||||
|
||||
int TabInterface::GetWidth()
|
||||
{
|
||||
return tabs[tabs.GetCount() - 1].Right() + style->margin * 2;
|
||||
}
|
||||
|
||||
int TabInterface::GetHeight()
|
||||
{
|
||||
return style->tabheight + style->sel.bottom + (int(hasscrollbar) * (TAB_SBHEIGHT + TAB_SBSEPARATOR));
|
||||
}
|
||||
|
||||
void TabInterface::ReposTabs()
|
||||
{
|
||||
if(!tabs.GetCount())
|
||||
return;
|
||||
|
||||
int j = 0;
|
||||
bool first = true;
|
||||
for(int i = 0; i < tabs.GetCount(); i++)
|
||||
{
|
||||
tabs[i].x = first ? 0 : tabs[j].Right();
|
||||
j = i;
|
||||
first = false;
|
||||
tabs[i].visible = true;
|
||||
tabs[i].y = 0;
|
||||
tabs[i].cx = GetWidth(i);
|
||||
tabs[i].cy = style->tabheight + style->sel.top;
|
||||
}
|
||||
if(hasscrollbar) scrollbar.SetTotal(GetWidth());
|
||||
}
|
||||
|
||||
void TabInterface::DrawLabel(Draw& w, int x, int y, Tab& t, bool isactive)
|
||||
{
|
||||
String fn = GetFileName(t.name);
|
||||
|
||||
if(horizontal)
|
||||
DrawFileName(w, x + TAB_MARGIN + (TAB_FILEICON + TAB_SPACEICON) * int(hasfileicon), (y - t.textsize.cy) / 2,
|
||||
t.textsize.cx, t.textsize.cy, fn.ToWString(),
|
||||
false, StdFont(), Black, LtBlue,
|
||||
Null, Null, false);
|
||||
else
|
||||
w.DrawText((y + t.textsize.cy) / 2 + 1,
|
||||
x + TAB_MARGIN + (TAB_FILEICON + TAB_SPACEICON) * int(hasfileicon),
|
||||
2700, fn.ToWString(),
|
||||
style->font);
|
||||
}
|
||||
|
||||
void TabInterface::DrawTab(Draw& w, Size &sz, int i)
|
||||
{
|
||||
Size isz = DockCtrlImgs::DClose().GetSize();
|
||||
int cnt = tabs.GetCount();
|
||||
Tab &t = tabs[i];
|
||||
|
||||
bool ac = i == active;
|
||||
bool hl = i == highlight;
|
||||
|
||||
int lx = i > 0 ? style->extendleft : 0;
|
||||
int x = t.x - (hasscrollbar ? scrollbar.GetPos() : 0) + style->margin - lx;
|
||||
|
||||
int ndx = !IsEnabled() ? CTRL_DISABLED :
|
||||
ac ? CTRL_PRESSED :
|
||||
hl ? CTRL_HOT : CTRL_NORMAL;
|
||||
|
||||
Image nimg;
|
||||
|
||||
int cx = t.cx + lx + (ac ? style->sel.right + style->sel.left : 0);
|
||||
int cy = ac ? t.cy - style->sel.top + style->sel.bottom : t.cy - style->sel.top;
|
||||
|
||||
int h = style->sel.top + style->sel.bottom;
|
||||
int hs = ac ? 0 : h;
|
||||
if(layout == LAYOUT_RIGHT || layout == LAYOUT_BOTTOM)
|
||||
hs = -hs;
|
||||
|
||||
ImageDraw img(cx, cy);
|
||||
|
||||
img.DrawRect(0, 0, cx, cy, SColorFace);
|
||||
|
||||
|
||||
const Value& sv = (cnt == 1 ? style->both : i == 0 ? style->first : i == cnt - 1 ? style->last : style->normal)[ndx];
|
||||
|
||||
ChPaint(img, 0, 0, cx, cy, sv);
|
||||
|
||||
if(hastabbutton && tabs.GetCount())
|
||||
img.DrawImage(t.cx - isz.cx - TAB_MARGIN,
|
||||
(cy + h - isz.cy) / 2,
|
||||
(ac || hl) ? (tabbutton == i ? DockCtrlImgs::DCloseh :
|
||||
ac ? DockCtrlImgs::DCloses : DockCtrlImgs::DClose) :
|
||||
DockCtrlImgs::DClose);
|
||||
|
||||
if(hasfileicon)
|
||||
img.DrawImage(TAB_MARGIN, (cy + h - t.icon.GetSize().cx) / 2, t.icon);
|
||||
|
||||
int shift = 0;
|
||||
switch(layout)
|
||||
{
|
||||
case LAYOUT_LEFT:
|
||||
nimg = MirrorVert(RotateAntiClockwise(img));
|
||||
break;
|
||||
case LAYOUT_TOP:
|
||||
nimg = img;
|
||||
break;
|
||||
case LAYOUT_RIGHT:
|
||||
nimg = RotateClockwise(img);
|
||||
shift = TAB_SBSEPARATOR;
|
||||
break;
|
||||
case LAYOUT_BOTTOM:
|
||||
nimg = MirrorVert(img);
|
||||
shift = TAB_SBSEPARATOR;
|
||||
break;
|
||||
}
|
||||
|
||||
if(ac)
|
||||
w.DrawImage(horizontal ? x - style->sel.left : shift,
|
||||
horizontal ? shift : x - style->sel.left,
|
||||
nimg);
|
||||
else
|
||||
w.DrawImage(horizontal ? x : style->sel.left - shift,
|
||||
horizontal ? style->sel.top - shift : x,
|
||||
nimg);
|
||||
|
||||
DrawLabel(w, x, cy + hs, t, ac);
|
||||
}
|
||||
|
||||
void TabInterface::Paint(Draw& d)
|
||||
{
|
||||
Size sz = GetSize();
|
||||
d.DrawRect(sz, SColorFace());
|
||||
|
||||
if(!horizontal)
|
||||
d.DrawRect(layout == LAYOUT_LEFT ? sz.cx - 1: 0, 0,
|
||||
1, sz.cy, LtGray());
|
||||
else
|
||||
d.DrawRect(0, layout == LAYOUT_TOP ? sz.cy - 1 : 0,
|
||||
sz.cx, 1, LtGray());
|
||||
|
||||
Fix(sz);
|
||||
|
||||
int tabcount = tabs.GetCount();
|
||||
|
||||
for(int i = 0; i < tabcount; i++)
|
||||
if(tabs[i].IsVisible() && active != i && i < tabcount)
|
||||
DrawTab(d, sz, i);
|
||||
|
||||
if(active >= 0 && active < tabcount)
|
||||
DrawTab(d, sz, active);
|
||||
|
||||
if(target >= 0)
|
||||
{
|
||||
int last = tabs.GetCount() - 1;
|
||||
int first = 0;
|
||||
|
||||
if(target != active && target != active + 1)
|
||||
{
|
||||
|
||||
int x = (target == last + 1 ? tabs[last].Right() : tabs[target].x)
|
||||
- (hasscrollbar ? scrollbar.GetPos() : 0) - (target <= first ? 1 : 2)
|
||||
+ style->margin - (target > 0 ? style->extendleft : 0);
|
||||
|
||||
int y = style->sel.top;
|
||||
|
||||
int cy = sz.cy - y;
|
||||
|
||||
Color c(255, 0, 0);
|
||||
|
||||
if(horizontal)
|
||||
{
|
||||
d.DrawRect(x + 1, y, 2, cy, c);
|
||||
d.DrawRect(x, y, 4, 1, c);
|
||||
d.DrawRect(x, y + cy - 1, 4, 1, c);
|
||||
}
|
||||
else
|
||||
{
|
||||
Swap(x, y);
|
||||
d.DrawRect(x, y + 1, cy, 2, c);
|
||||
d.DrawRect(x, y, 1, 4, c);
|
||||
d.DrawRect(x + cy - 1, y, 1, 4, c);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void TabInterface::LeftDown(Point p, dword keyflags)
|
||||
{
|
||||
if(keyflags & K_SHIFT)
|
||||
{
|
||||
highlight = -1;
|
||||
Refresh();
|
||||
SetCapture();
|
||||
oldp = p;
|
||||
return;
|
||||
}
|
||||
|
||||
isctrl = keyflags & K_CTRL;
|
||||
if(isctrl)
|
||||
return;
|
||||
|
||||
if(tabbutton >= 0)
|
||||
{
|
||||
int i = Find(tabbutton);
|
||||
if(i == -1 && active >= 0)
|
||||
i = active;
|
||||
|
||||
if(i >= 0)
|
||||
{
|
||||
DockableCtrl* dock = tabs[i].dock;
|
||||
if(dock)
|
||||
WhenClose(tabbutton, *dock);
|
||||
}
|
||||
}
|
||||
|
||||
if(highlight >= 0)
|
||||
{
|
||||
SetActiveTab(highlight);
|
||||
if(active >= 0)
|
||||
WhenActive(active, *tabs[active].dock);
|
||||
}
|
||||
}
|
||||
|
||||
void TabInterface::LeftUp(Point p, dword keyflags)
|
||||
{
|
||||
ReleaseCapture();
|
||||
}
|
||||
|
||||
void TabInterface::MiddleDrag(Point p, dword keyflags)
|
||||
{
|
||||
if(!isdraggable) return;
|
||||
isdragged = true;
|
||||
DoDragAndDrop(InternalClip(*this, Format(internalname, this)));
|
||||
}
|
||||
|
||||
void TabInterface::LeftDrag(Point p, dword keyflags)
|
||||
{
|
||||
if(keyflags & K_SHIFT)
|
||||
return;
|
||||
if(highlight < 0)
|
||||
return;
|
||||
|
||||
if(isctrl)
|
||||
{
|
||||
isdragged = true;
|
||||
DoDragAndDrop(InternalClip(*this, Format(internalname, this)));
|
||||
return;
|
||||
}
|
||||
|
||||
if(highlight >= 0)
|
||||
{
|
||||
Fix(p);
|
||||
SetActiveTab(highlight);
|
||||
p.x += (int(hasscrollbar) * scrollbar.GetPos());
|
||||
if(tabs[active].HasMouse(p))
|
||||
WhenDrag(active, *tabs[active].dock);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
void TabInterface::RightDown(Point p, dword keyflags)
|
||||
{
|
||||
if(highlight >= 0)
|
||||
SetActiveTab(highlight);
|
||||
WhenContext(active, *tabs[active].dock);
|
||||
}
|
||||
|
||||
void TabInterface::RightUp(Point p, dword keyflags)
|
||||
{
|
||||
}
|
||||
|
||||
|
||||
void TabInterface::MouseMove(Point p, dword keyflags)
|
||||
{
|
||||
Fix(p);
|
||||
if(HasCapture() && hasscrollbar)
|
||||
{
|
||||
scrollbar.AddPos(p.x - oldp.x, true);
|
||||
oldp = p;
|
||||
return;
|
||||
}
|
||||
|
||||
p.x += (int(hasscrollbar) * scrollbar.GetPos()) - style->margin + style->extendleft;
|
||||
Size sz = GetSize();
|
||||
Fix(sz);
|
||||
int h = highlight;
|
||||
bool istabbutton = false;
|
||||
bool istab = false;
|
||||
for(int i = 0; i < tabs.GetCount(); i++)
|
||||
{
|
||||
if(tabs[i].HasMouse(p))
|
||||
{
|
||||
istab = true;
|
||||
//int h = sz.cy + (active == i ? 0 : style->sel.top);
|
||||
int h = style->sel.top + style->sel.bottom;
|
||||
int hs = active == i ? style->sel.top : h;
|
||||
if(layout == LAYOUT_RIGHT || layout == LAYOUT_BOTTOM)
|
||||
hs = -hs;
|
||||
hs += sz.cy;
|
||||
int ws = active == i ? style->sel.left : 0;
|
||||
istabbutton = hastabbutton ? tabs[i].HasMouseButton(p, ws, hs) : false;
|
||||
if(highlight != i || (istabbutton && tabbutton != i))
|
||||
{
|
||||
tabbutton = istabbutton ? i : -1;
|
||||
highlight = i;
|
||||
WhenHighlight();
|
||||
Refresh();
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if(!istab && h >= 0)
|
||||
{
|
||||
highlight = -1;
|
||||
WhenHighlight();
|
||||
Refresh();
|
||||
}
|
||||
|
||||
if(!istabbutton && tabbutton >= 0)
|
||||
{
|
||||
tabbutton = -1;
|
||||
Refresh();
|
||||
}
|
||||
}
|
||||
|
||||
void TabInterface::MouseWheel(Point p, int zdelta, dword keyflags)
|
||||
{
|
||||
if(!hasscrollbar) return;
|
||||
scrollbar.AddPos(-zdelta / 4, true);
|
||||
MouseMove(p, 0);
|
||||
}
|
||||
|
||||
|
||||
void TabInterface::MouseLeave()
|
||||
{
|
||||
if(isdragged)
|
||||
return;
|
||||
highlight = -1;
|
||||
tabbutton = -1;
|
||||
Refresh();
|
||||
}
|
||||
|
||||
int TabInterface::GetTargetTab(Point p)
|
||||
{
|
||||
Fix(p);
|
||||
p.x += (hasscrollbar ? scrollbar.GetPos() : 0);
|
||||
|
||||
int f = 0;
|
||||
int l = tabs.GetCount() - 1;
|
||||
|
||||
if(tabs[f].visible && p.x < tabs[f].x + tabs[f].cx / 2)
|
||||
return f;
|
||||
|
||||
for(int i = l; i >= f; i--)
|
||||
if(tabs[i].visible && p.x >= tabs[i].x + tabs[i].cx / 2)
|
||||
return i == l ? i + 1 : GetNext(i);
|
||||
return -1;
|
||||
}
|
||||
|
||||
int TabInterface::GetSourceTab(Point p)
|
||||
{
|
||||
int cnt = tabs.GetCount();
|
||||
if(((active >= 0 && active < cnt) || (highlight >= 0 && highlight < cnt)))
|
||||
{
|
||||
for(int i = tabs.GetCount() - 1; i >= 0; i--)
|
||||
if(tabs[i].visible && tabs[i].HasMouse(p))
|
||||
return (source = i);
|
||||
}
|
||||
return (source = highlight);
|
||||
}
|
||||
|
||||
void TabInterface::DragAndDrop(Point p, PasteClip& d)
|
||||
{
|
||||
int c = GetTargetTab(p);
|
||||
int tab = isctrl ? highlight : active;
|
||||
if(tab == -1) return;
|
||||
|
||||
bool sametab = c == tab || c == tab + 1;
|
||||
bool internal = AcceptInternal<TabInterface>(d, internalname);
|
||||
|
||||
if(!sametab && d.IsAccepted())
|
||||
{
|
||||
if(internal)
|
||||
{
|
||||
int id = tabs[active].id;
|
||||
Tab t = tabs[tab];
|
||||
tabs.Insert(c, t);
|
||||
tabs.Remove(tab + int(c < tab));
|
||||
active = Find(id);
|
||||
isdragged = false;
|
||||
ReposTabs();
|
||||
return;
|
||||
}
|
||||
else if(d.IsPaste())
|
||||
{
|
||||
CancelMode();
|
||||
return;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
//d.Reject();
|
||||
//unfortunately after Reject DragLeave stops working until d is accepted
|
||||
}
|
||||
|
||||
if(c != target)
|
||||
{
|
||||
target = c;
|
||||
Refresh();
|
||||
}
|
||||
}
|
||||
|
||||
void TabInterface::DragEnter()
|
||||
{
|
||||
}
|
||||
|
||||
void TabInterface::DragLeave()
|
||||
{
|
||||
target = -1;
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void TabInterface::DragRepeat(Point p)
|
||||
{
|
||||
{
|
||||
int dx = GetDragScroll(this, p, 16).x;
|
||||
if(dx != 0 && hasscrollbar)
|
||||
scrollbar.AddPos(dx);
|
||||
}
|
||||
}
|
||||
|
||||
void TabInterface::CancelMode()
|
||||
{
|
||||
isdragged = false;
|
||||
target = -1;
|
||||
Refresh();
|
||||
}
|
||||
|
||||
|
||||
TabInterface& TabInterface::SetLayout(int l)
|
||||
{
|
||||
DockCtrlCustomFrame::SetLayout(l);
|
||||
switch(l)
|
||||
{
|
||||
case LAYOUT_LEFT:
|
||||
horizontal = scrollbar.horizontal = false;
|
||||
scrollbar.SetLayout(LAYOUT_RIGHT);
|
||||
break;
|
||||
case LAYOUT_TOP:
|
||||
horizontal = scrollbar.horizontal = true;
|
||||
scrollbar.SetLayout(LAYOUT_BOTTOM);
|
||||
break;
|
||||
case LAYOUT_RIGHT:
|
||||
horizontal = scrollbar.horizontal = false;
|
||||
scrollbar.SetLayout(LAYOUT_LEFT);
|
||||
break;
|
||||
case LAYOUT_BOTTOM:
|
||||
horizontal = scrollbar.horizontal = true;
|
||||
scrollbar.SetLayout(LAYOUT_TOP);
|
||||
break;
|
||||
}
|
||||
RefreshLayout();
|
||||
return *this;
|
||||
}
|
||||
|
||||
TabInterface::TabInterface()
|
||||
{
|
||||
internalname = "tabs";
|
||||
|
||||
id = -1;
|
||||
active = -1;
|
||||
highlight = -1;
|
||||
visible = -1;
|
||||
fileicon = -1;
|
||||
tabbutton = -1;
|
||||
target = -1; // drag target.
|
||||
source = -1; // drag source.
|
||||
|
||||
hasfileicon = false;
|
||||
hastabbutton = true;
|
||||
isdraggable = true;
|
||||
isctrl = false;
|
||||
isdragged = false;
|
||||
|
||||
SetStyle(TabCtrl::StyleDefault());
|
||||
DockCtrlCustomFrame::layout = LAYOUT_BOTTOM;
|
||||
HasScrollBar(true);
|
||||
SetSize(GetHeight() + 2);
|
||||
BackPaint();
|
||||
}
|
||||
|
||||
TabInterface::~TabInterface()
|
||||
{
|
||||
for(int i = 0; i < tabs.GetCount(); i++)
|
||||
tabs.Remove(i);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------------------------
|
||||
|
||||
TabInterface::TabScrollBar::TabScrollBar()
|
||||
{
|
||||
DockCtrlCustomFrame::layout = LAYOUT_TOP;
|
||||
DockCtrlCustomFrame::SetSize(TAB_SBHEIGHT);
|
||||
|
||||
total = 0;
|
||||
pos = 0;
|
||||
ps = 0;
|
||||
start_pos = 0;
|
||||
new_pos = 0;
|
||||
old_pos = 0;
|
||||
ready = false;
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::Paint(Draw &w)
|
||||
{
|
||||
if(!ready)
|
||||
{
|
||||
UpdatePos();
|
||||
ready = true;
|
||||
}
|
||||
Size sz = GetSize();
|
||||
|
||||
w.DrawRect(sz, SColorFace());
|
||||
|
||||
if(horizontal)
|
||||
{
|
||||
if(total > sz.cx)
|
||||
w.DrawRect(ffloor(pos), 1, fceil(size), 2, Blue);
|
||||
else
|
||||
w.DrawRect(0, sz.cy - 1, sz.cx, 1, White);
|
||||
}
|
||||
else
|
||||
{
|
||||
if(total > sz.cy)
|
||||
w.DrawRect(1, ffloor(pos), 2, fceil(size), Blue);
|
||||
else
|
||||
w.DrawRect(sz.cx - 1, 0, 1, sz.cy, White);
|
||||
}
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::LeftDown(Point p, dword keyflags)
|
||||
{
|
||||
SetCapture();
|
||||
Fix(p);
|
||||
old_pos = new_pos = p.x;
|
||||
if(p.x < pos || p.x > pos + size)
|
||||
start_pos = size / 2;
|
||||
else
|
||||
start_pos = UPP::tabs(p.x - pos);
|
||||
UpdatePos();
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::LeftUp(Point p, dword keyflags)
|
||||
{
|
||||
ReleaseCapture();
|
||||
Fix(p);
|
||||
old_pos = p.x;
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::MouseMove(Point p, dword keyflags)
|
||||
{
|
||||
if(!HasCapture())
|
||||
return;
|
||||
Fix(p);
|
||||
new_pos = p.x;
|
||||
UpdatePos();
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::MouseWheel(Point p, int zdelta, dword keyflags)
|
||||
{
|
||||
AddPos(-zdelta / 4, true);
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::Layout()
|
||||
{
|
||||
UpdatePos(false);
|
||||
}
|
||||
|
||||
int TabInterface::TabScrollBar::GetPos() const
|
||||
{
|
||||
return ffloor(ps);
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::SetPos(int p, bool dontscale)
|
||||
{
|
||||
Fix(sz);
|
||||
pos = total > 0 ? dontscale ? p : iscale(p, sz.cx, total) : 0;
|
||||
UpdatePos(false);
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::AddPos(int p, bool dontscale)
|
||||
{
|
||||
Fix(sz);
|
||||
pos += total > 0 ? dontscale ? p : iscale(p, sz.cx, total) : 0;
|
||||
UpdatePos(false);
|
||||
Refresh();
|
||||
}
|
||||
|
||||
int TabInterface::TabScrollBar::GetTotal() const
|
||||
{
|
||||
return total;
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::AddTotal(int t)
|
||||
{
|
||||
total += t;
|
||||
UpdatePos();
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::SetTotal(int t)
|
||||
{
|
||||
bool upd = total < t;
|
||||
total = t;
|
||||
UpdatePos(upd);
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::GoEnd()
|
||||
{
|
||||
pos = total;
|
||||
UpdatePos(false);
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::GoBegin()
|
||||
{
|
||||
pos = 0;
|
||||
UpdatePos(false);
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::Set(const TabScrollBar& t)
|
||||
{
|
||||
total = t.total;
|
||||
pos = t.pos;
|
||||
ps = t.ps;
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void TabInterface::TabScrollBar::UpdatePos(bool update)
|
||||
{
|
||||
sz = GetSize();
|
||||
Fix(sz);
|
||||
if(total <= 0 || sz.cx <= 0)
|
||||
cs = ics = 0;
|
||||
else
|
||||
{
|
||||
cs = sz.cx / ((double) total + 0.5);
|
||||
ics = total / ((double) sz.cx);
|
||||
}
|
||||
size = sz.cx * cs;
|
||||
if(update)
|
||||
pos = new_pos - start_pos;
|
||||
if(pos < 0)
|
||||
pos = 0;
|
||||
else if(pos + size > sz.cx)
|
||||
pos = sz.cx - size;
|
||||
|
||||
ps = total > sz.cx ? pos * ics : 0;
|
||||
WhenScroll();
|
||||
}
|
||||
|
||||
TabInterface::TabScrollBar& TabInterface::TabScrollBar::SetLayout(int l)
|
||||
{
|
||||
layout = l;
|
||||
RefreshLayout();
|
||||
return *this;
|
||||
}
|
||||
979
archive/DockCtrl/DockWindow.cpp
Normal file
979
archive/DockCtrl/DockWindow.cpp
Normal file
|
|
@ -0,0 +1,979 @@
|
|||
#include "DockCtrl/DockCtrl.h"
|
||||
|
||||
#define IMAGEFILE <DockCtrl/DockableCtrl.iml>
|
||||
#define IMAGECLASS DockWindowImages
|
||||
#include <Draw/iml.h>
|
||||
|
||||
//===============================================
|
||||
// DockWindow class:
|
||||
// A dockable window widget.
|
||||
//===============================================
|
||||
|
||||
DockWindow::DockWindow() : DockableCtrl()
|
||||
{
|
||||
SetType(TYPE_DOCKWINDOW);
|
||||
|
||||
ownertab = NULL;
|
||||
ownerbar = NULL;
|
||||
menubar = NULL;
|
||||
toolbar = NULL;
|
||||
statusbar = NULL;
|
||||
hasstatusbar = false;
|
||||
hasbarbuttons = false;
|
||||
hastoolbar = false;
|
||||
hasmenubar = false;
|
||||
|
||||
shutbutton << THISBACK(OnShutButton);
|
||||
autohidebutton << THISBACK(OnAutoHideButton);
|
||||
menubutton << THISBACK(OnMenuButton);
|
||||
|
||||
dragbar.SetOwner(this);
|
||||
SetStyle(DockCtrlChStyle::StyleDefault());
|
||||
SetFrame(FieldFrame());
|
||||
ShowDragBar();
|
||||
ShowDragBarButtons(true);
|
||||
Sizeable().Zoomable().ToolWindow().TopMost(false).MinimizeBox().MaximizeBox().BackPaint();
|
||||
WhenContextMenu = THISBACK(DockWindowMenu);
|
||||
|
||||
}
|
||||
|
||||
DockWindow::~DockWindow()
|
||||
{
|
||||
}
|
||||
|
||||
void DockWindow::Dock(int alignment, int state, int position, bool sizecheck)
|
||||
{
|
||||
if(Alignment() == alignment && (!IsHidden() && !IsAutoHidden())) return;
|
||||
else if(IsTabbed()) GetOwnerTab()->Detach(*this);
|
||||
else if(IsFloating()) ShutWindow();
|
||||
else if(IsAutoHidden()) GetBase().GetHideBar(Alignment()).Detach(*this);
|
||||
else
|
||||
{
|
||||
if(sizecheck) ReSize();
|
||||
GetBase().Detach(*this);
|
||||
}
|
||||
DockingStyle(alignment, state, position);
|
||||
ShowDragBar();
|
||||
GetBase().Dock(*this);
|
||||
}
|
||||
|
||||
void DockWindow::FloatEx(Rect r)
|
||||
{
|
||||
if(IsTabbed() && IsChild()) GetOwnerTab()->Detach(*this);
|
||||
else if(IsAutoHidden()) GetBase().GetHideBar(Alignment()).Detach(*this);
|
||||
else if(!IsShut()) GetBase().Detach(*this);
|
||||
OpenWindow(r.left, r.top, r.right, r.bottom);
|
||||
DockingStyle(DOCK_NONE, STATE_SHOW, 0);
|
||||
GetBase().RefreshPanel();
|
||||
}
|
||||
|
||||
void DockWindow::Float()
|
||||
{
|
||||
if(IsFloating()) return;
|
||||
Rect r = GetScreenView();
|
||||
Point p = GetMousePos();
|
||||
|
||||
if(IsTabbed())
|
||||
{
|
||||
GetOwnerTab()->Detach(*this);
|
||||
Size sizehint = GetSizeHint();
|
||||
r.left = p.x - 4;
|
||||
r.top = p.y + 4;
|
||||
r.right = p.x + sizehint.cx;
|
||||
r.bottom = p.y + sizehint.cy;
|
||||
}
|
||||
else
|
||||
{
|
||||
if(r.top > p.y) r.top -= r.top - p.y - 4;
|
||||
r.right = r.left + r.Width();
|
||||
r.bottom = r.top + r.Height();
|
||||
}
|
||||
if(IsAutoHidden()) GetBase().GetHideBar(Alignment()).Detach(*this);
|
||||
if(!IsShut()) GetBase().Detach(*this);
|
||||
OpenWindow(r);
|
||||
DockingStyle(DOCK_NONE, STATE_SHOW, 0);
|
||||
GetBase().RefreshPanel();
|
||||
}
|
||||
|
||||
void DockWindow::Show()
|
||||
{
|
||||
if(!IsHidden() || IsTabbed()) return;
|
||||
Dock(Alignment(), STATE_SHOW, Position());
|
||||
GetBase().RefreshPanel();
|
||||
}
|
||||
|
||||
void DockWindow::Hide()
|
||||
{
|
||||
if(IsTabbed()) return;
|
||||
if(IsHidden())
|
||||
{
|
||||
Show();
|
||||
return;
|
||||
}
|
||||
ShutWindow();
|
||||
GetBase().Detach(*this);
|
||||
DockingStyle(Alignment(), STATE_HIDE, Position());
|
||||
GetBase().RefreshPanel();
|
||||
}
|
||||
|
||||
void DockWindow::AutoHide()
|
||||
{
|
||||
if(IsFloating()) return;
|
||||
if(IsAutoHidden())
|
||||
{
|
||||
GetBase().GetHideBar(Alignment()).Detach(*this);
|
||||
GetBase().Dock(this->DockingStyle(Alignment(), STATE_SHOW, Position()));
|
||||
return;
|
||||
}
|
||||
int alignment = Alignment();
|
||||
int state = STATE_AUTO;
|
||||
int position = Position();
|
||||
|
||||
if(IsTabbed())
|
||||
{
|
||||
TabWindow* tabwindow = GetOwnerTab()->GetBaseTab();
|
||||
if(tabwindow->IsFloating()) return;
|
||||
alignment = tabwindow->Alignment();
|
||||
position = tabwindow->Position();
|
||||
GetOwnerTab()->Detach(*this);
|
||||
}
|
||||
else
|
||||
{
|
||||
ReSize();
|
||||
GetBase().Detach(*this);
|
||||
}
|
||||
DockingStyle(alignment, state, position);
|
||||
GetBase().Dock(*this);
|
||||
GetBase().RefreshPanel();
|
||||
}
|
||||
|
||||
void DockWindow::Shut()
|
||||
{
|
||||
if(IsShut()) return;
|
||||
ShutWindow();
|
||||
if(IsTabbed()) GetOwnerTab()->Detach(*this);
|
||||
else if(IsAutoHidden()) GetBase().GetHideBar(Alignment()).Detach(*this);
|
||||
else if(IsFloating()) Remove();
|
||||
else GetBase().Detach(*this);
|
||||
DockingStyle(DOCK_NONE, STATE_SHUT, 0);
|
||||
GetBase().RefreshPanel();
|
||||
}
|
||||
|
||||
void DockWindow::Menu()
|
||||
{
|
||||
ContextMenu();
|
||||
}
|
||||
|
||||
DockWindow& DockWindow::AddMenuBar(MenuBar& bar)
|
||||
{
|
||||
AddChildBar(bar);
|
||||
menubar = &bar;
|
||||
hasmenubar = true;
|
||||
return *this;
|
||||
}
|
||||
|
||||
DockWindow& DockWindow::AddToolBar(ToolBar& bar)
|
||||
{
|
||||
AddChildBar(bar);
|
||||
toolbar = &bar;
|
||||
hastoolbar = true;
|
||||
return *this;
|
||||
}
|
||||
|
||||
DockWindow& DockWindow::AddStatusBar(StatusBar& bar)
|
||||
{
|
||||
AddChildBar(bar.Height(18));
|
||||
statusbar = &bar;
|
||||
hasstatusbar = true;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void DockWindow::HideDragBar()
|
||||
{
|
||||
if(!HasDragBar()) return;
|
||||
RemoveFrame(dragbar);
|
||||
DockableCtrl::HideDragBar();
|
||||
}
|
||||
|
||||
void DockWindow::ShowDragBar()
|
||||
{
|
||||
if(HasDragBar()) return;
|
||||
InsertFrame(0, dragbar);
|
||||
DockableCtrl::ShowDragBar();
|
||||
}
|
||||
|
||||
Rect DockWindow::GetCtrlRect()
|
||||
{
|
||||
if(!HasDragBar()) return GetScreenRect();
|
||||
Rect bar = dragbar.GetScreenRect();
|
||||
Rect wnd = GetScreenRect();
|
||||
wnd.top = bar.top;
|
||||
return wnd;
|
||||
}
|
||||
|
||||
Size DockWindow::GetCtrlSize()
|
||||
{
|
||||
return GetCtrlRect().GetSize();
|
||||
}
|
||||
|
||||
void DockWindow::Paint(Draw& d)
|
||||
{
|
||||
TopWindow::Paint(d);
|
||||
}
|
||||
|
||||
DockWindow& DockWindow::SetStyle(const DockCtrlChStyle::Style& st)
|
||||
{
|
||||
style = &st;
|
||||
dragbar.SetStyle(st);
|
||||
shutbutton.SetImage(style->barshut[0], style->barshut[1], style->barshut[2]);
|
||||
menubutton.SetImage(style->barmenu[0],style->barmenu[1], style->barmenu[2]);
|
||||
autohidebutton.SetImage(style->barhide[0], style->barhide[1], style->barhide[2]);
|
||||
RefreshLayoutDeep();
|
||||
return *this;
|
||||
}
|
||||
|
||||
const DockCtrlChStyle::Style* DockWindow::GetStyle()
|
||||
{
|
||||
return style ? style : &DockCtrlChStyle::StyleDefault();
|
||||
}
|
||||
|
||||
void DockWindow::MouseMove(Point p, dword keyflags)
|
||||
{
|
||||
TopWindow::MouseMove(p, keyflags);
|
||||
}
|
||||
|
||||
void DockWindow::ChildMouseEvent(Ctrl *child, int event, Point p, int zdelta, dword keyflags)
|
||||
{
|
||||
if(HasDragBar() && child == &dragbar)
|
||||
{
|
||||
if(event == LEFTDRAG) StartWindowDrag();
|
||||
if(event == LEFTDOUBLE && IsAutoHidden()) Dock(Alignment(), STATE_SHOW, Position());
|
||||
if(event == RIGHTDOWN && !hasbarbuttons) ContextMenu();
|
||||
}
|
||||
TopWindow::ChildMouseEvent(child, event, p, zdelta, keyflags);
|
||||
}
|
||||
|
||||
void DockWindow::OnMenuButton()
|
||||
{
|
||||
ContextMenu();
|
||||
}
|
||||
|
||||
void DockWindow::OnShutButton()
|
||||
{
|
||||
Shut();
|
||||
}
|
||||
|
||||
void DockWindow::OnAutoHideButton()
|
||||
{
|
||||
AutoHide();
|
||||
}
|
||||
|
||||
DockWindow& DockWindow::ShowDragBarButtons(bool b)
|
||||
{
|
||||
if(b && hasbarbuttons) return *this;
|
||||
else if(b && !hasbarbuttons)
|
||||
{
|
||||
hasbarbuttons = b;
|
||||
int cx = style->barheight - 8;
|
||||
int cy = style->barheight - 8;
|
||||
|
||||
dragbar << shutbutton.RightPos(2, cy).TopPos(2, cy).Tip(t_("Close"));
|
||||
dragbar << autohidebutton.RightPos(cy + 4, cy).TopPos(2, cy).Tip(t_("Auto Hide"));
|
||||
dragbar << menubutton.RightPos((2 * cy) + 6, cy).TopPos(2, cy).Tip(t_("Window Position"));
|
||||
}
|
||||
else if(!b && hasbarbuttons)
|
||||
{
|
||||
hasbarbuttons = b;
|
||||
shutbutton.Remove();
|
||||
autohidebutton.Remove();
|
||||
menubutton.Remove();
|
||||
}
|
||||
dragbar.ShowButtons(b);
|
||||
return *this;
|
||||
}
|
||||
|
||||
void DockWindow::DockWindowMenu(Bar& bar)
|
||||
{
|
||||
bool floatingbase = false;
|
||||
TabWindow* c = GetOwnerTab();
|
||||
if(c) floatingbase = c->GetBaseTab()->IsFloating();
|
||||
|
||||
bar.Add(t_("Dock"), THISBACK(DockWindowDockMenu));
|
||||
bar.Add(!IsFloating(), t_("Float"),THISBACK(Float));
|
||||
bar.Separator();
|
||||
bar.Add(IsDocked(), IsHidden() ? t_("Show") : t_("Hide"), THISBACK(Hide));
|
||||
bar.Add(!IsFloating() && !floatingbase, t_("Auto Hide"), THISBACK(AutoHide));
|
||||
bar.Separator();
|
||||
bar.Add(t_("Settings"), THISBACK(Settings));
|
||||
bar.Separator();
|
||||
bar.Add(t_("Close"), DockWindowImages::CClose(), THISBACK(Shut));
|
||||
}
|
||||
|
||||
void DockWindow::DockWindowDockMenu(Bar& bar)
|
||||
{
|
||||
if(GetBase().IsSideAllowed(DOCK_TOP)) bar.Add(Alignment() == DOCK_TOP ? 0 : 1, t_("Top"), THISBACK4(Dock, (int)DOCK_TOP, (int)STATE_SHOW, Position(), 0));
|
||||
if(GetBase().IsSideAllowed(DOCK_LEFT)) bar.Add(Alignment() == DOCK_LEFT ? 0 : 1, t_("Left"), THISBACK4(Dock, (int)DOCK_LEFT, (int)STATE_SHOW, Position(), 0));
|
||||
if(GetBase().IsSideAllowed(DOCK_RIGHT)) bar.Add(Alignment() == DOCK_RIGHT ? 0 : 1, t_("Right"), THISBACK4(Dock, (int)DOCK_RIGHT, (int)STATE_SHOW, Position(), 0));
|
||||
if(GetBase().IsSideAllowed(DOCK_BOTTOM)) bar.Add(Alignment() == DOCK_BOTTOM ? 0 : 1, t_("Bottom"), THISBACK4(Dock, (int)DOCK_BOTTOM, (int)STATE_SHOW, Position(), 0));
|
||||
}
|
||||
|
||||
void DockWindow::Serialize(Stream& s)
|
||||
{
|
||||
int type = GetType();
|
||||
int alignment = Alignment();
|
||||
int state = State();
|
||||
int position = Position();
|
||||
int id = -1;
|
||||
Size sz = GetSizeHint();
|
||||
Rect r = GetRect();
|
||||
|
||||
if(s.IsStoring())
|
||||
{
|
||||
if(IsAutoHidden()) SetSizeHint(Size(0, 0));
|
||||
id = GetBase().GetCtrlRecord(*this)->id;
|
||||
s / type;
|
||||
s / id;
|
||||
s / alignment / state / position;
|
||||
sz.Serialize(s);
|
||||
if(IsFloating())
|
||||
{
|
||||
r.Serialize(s);
|
||||
SerializePlacement(s, true);
|
||||
}
|
||||
}
|
||||
if(s.IsLoading())
|
||||
{
|
||||
TabWindow* tabwindow = GetOwnerTab();
|
||||
s / alignment / state / position;
|
||||
sz.Serialize(s);
|
||||
SetSize(sz);
|
||||
if(tabwindow) tabwindow->Attach(*this);
|
||||
else if(alignment == DOCK_NONE && state != STATE_SHUT)
|
||||
{
|
||||
r.Serialize(s);
|
||||
Shut();
|
||||
FloatEx(Rect(r.left, r.top, 10, 10));
|
||||
SerializePlacement(s, true);
|
||||
}
|
||||
else
|
||||
{
|
||||
Shut();
|
||||
Dock(alignment, state, position, false);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//===============================================
|
||||
// DockWindow::DragBarButton
|
||||
// Nested helper class for DockWindow
|
||||
//===============================================
|
||||
|
||||
Ctrl& DockWindow::DragBarButton::SetImage(const Image& normal, const Image& highlighted, const Image& pushed)
|
||||
{
|
||||
nimage = normal;
|
||||
himage = highlighted;
|
||||
pimage = pushed;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void DockWindow::DragBarButton::Paint(Draw& d)
|
||||
{
|
||||
Size sz = GetSize();
|
||||
d.DrawImage(0 , 0, sz.cx, sz.cy, (IsPush() && HasMouse() ? pimage : (!IsPush() && HasMouse() ? himage : nimage)));
|
||||
}
|
||||
|
||||
//===============================================
|
||||
// DockWindow::DragBar
|
||||
// Nested helper class for DockWindow
|
||||
//===============================================
|
||||
|
||||
DockWindow::DragBar::DragBar()
|
||||
{
|
||||
SetStyle(DockCtrlChStyle::StyleDefault());
|
||||
SetFrame(FieldFrame());
|
||||
SetSize(style->barheight);
|
||||
ShowButtons();
|
||||
}
|
||||
|
||||
int DockWindow::DragBar::GetWidth()
|
||||
{
|
||||
Size sz = GetTextSize(GetOwner().GetLabel(), style->font);
|
||||
return BAR_MARGIN * 2 + sz.cx;
|
||||
}
|
||||
|
||||
int DockWindow::DragBar::GetHeight()
|
||||
{
|
||||
return style->barheight + 4;
|
||||
}
|
||||
|
||||
void DockWindow::DragBar::FrameAddSize(Size& sz)
|
||||
{
|
||||
sz += GetHeight();
|
||||
}
|
||||
|
||||
void DockWindow::DragBar::Paint(Draw& d)
|
||||
{
|
||||
Size sz = GetSize();
|
||||
|
||||
Image icon = GetOwner().GetIcon();
|
||||
bool hasicon = false;
|
||||
|
||||
ImageDraw skin(sz.cx, sz.cy);
|
||||
ChPaint(skin, 0, 0, GetSize().cx, GetSize().cy, style->barbackground[0]);
|
||||
Image imgs = skin;
|
||||
((GUI_GlobalStyle() >= GUISTYLE_XP) && (style != &DockCtrlChStyle::StyleClassic())) ?
|
||||
// See CtrlsImg for proper rectangle value.
|
||||
d.DrawImage(GetRect(), imgs, Rect(4, 4, 2, 14)) :
|
||||
d.DrawRect(GetSize(), SColorFace());
|
||||
|
||||
|
||||
if(!icon.IsNullInstance())
|
||||
{
|
||||
hasicon = true;
|
||||
d.DrawImage(BAR_MARGIN, GetHeight() / icon.GetSize().cy, style->barheight - 8, style->barheight - 8, icon);
|
||||
}
|
||||
d.DrawText(BAR_MARGIN + (BAR_FILEICON + BAR_SPACEICON) * int(hasicon), GetHeight() / 12, GetOwner().GetLabel(), style->font);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------------------------
|
||||
|
||||
TabWindow::TabWindow()
|
||||
{
|
||||
SetType(TYPE_TABWINDOW);
|
||||
|
||||
destroyed = false;
|
||||
animating = false;
|
||||
groupwindow = false;
|
||||
position = -1;
|
||||
previous = -1;
|
||||
nestlevel = 0;
|
||||
childcount = 0;
|
||||
activectrl = NULL;
|
||||
|
||||
AddFrame(tabs.SetLayout(DockCtrlCustomFrame::LAYOUT_BOTTOM));
|
||||
|
||||
tabs.WhenSelect = THISBACK(OnActiveTab);
|
||||
tabs.WhenClose = THISBACK(OnTabClose);
|
||||
tabs.WhenContext = THISBACK(OnTabContextMenu);
|
||||
tabs.WhenDrag = THISBACK(OnTabDrag);
|
||||
tabs.WhenActive = THISBACK(OnTabActive);
|
||||
}
|
||||
|
||||
TabWindow::~TabWindow()
|
||||
{
|
||||
position = -1;
|
||||
previous = -1;
|
||||
nestlevel = 0;
|
||||
childcount = 0;
|
||||
groupwindow = false;
|
||||
activectrl = NULL;
|
||||
}
|
||||
|
||||
void TabWindow::Attach(DockableCtrl& ctrl, int makeactive)
|
||||
{
|
||||
if(ctrl.IsTabWindow())
|
||||
{
|
||||
if(GetBase().DockBase::tabsnested || IsGroupWindow()) AttachNested(ctrl, makeactive);
|
||||
else AttachNormal(ctrl, makeactive);
|
||||
}
|
||||
else Attach0(ctrl, makeactive);
|
||||
}
|
||||
|
||||
|
||||
void TabWindow::AttachNormal(DockableCtrl& ctrl, int makeactive)
|
||||
{
|
||||
TabWindow& tabwindow = reinterpret_cast<TabWindow&>(ctrl);
|
||||
int ncount = tabwindow.ChildCount();
|
||||
|
||||
DockableCtrl* lc = tabwindow.GetChildAt(ncount);
|
||||
|
||||
if(lc)
|
||||
{
|
||||
bool transfered = false;
|
||||
for(int i = 0; i < ncount - 1 ; i++)
|
||||
{
|
||||
DockableCtrl* c = tabwindow.GetChildAt(i + 1);
|
||||
if(c)
|
||||
{
|
||||
Attach(*c);
|
||||
transfered = true;
|
||||
}
|
||||
}
|
||||
if(transfered)
|
||||
{
|
||||
Attach(*lc);
|
||||
}
|
||||
tabwindow.TabWindow::destroyed = true;
|
||||
}
|
||||
}
|
||||
|
||||
void TabWindow::AttachNested(DockableCtrl& ctrl, int makeactive)
|
||||
{
|
||||
TabWindow& child = reinterpret_cast<TabWindow&>(ctrl);
|
||||
child.SetNestLevel(GetNestLevel() + 1);
|
||||
Attach0(ctrl, makeactive);
|
||||
}
|
||||
|
||||
void TabWindow::Attach0(DockableCtrl& ctrl, int makeactive)
|
||||
{
|
||||
reinterpret_cast<DockWindow&>(ctrl).SetOwnerTab(this);
|
||||
ctrl.HideDragBar();
|
||||
Add(ctrl.DockingStyle(DOCK_TABBED, STATE_TABBED, 0).SetBase(&GetBase()).SizePos());
|
||||
ReposChilds();
|
||||
tabs.Add(ctrl, makeactive);
|
||||
childcount++;
|
||||
|
||||
SetActive(GetActiveTab());
|
||||
GetBase().AddCtrlRecord(ctrl);
|
||||
RefreshTabWindowLabel(ctrl);
|
||||
GetBase().RefreshWidgetLayout();
|
||||
GetBase().RefreshPanel();
|
||||
}
|
||||
|
||||
|
||||
void TabWindow::Detach(DockableCtrl& ctrl)
|
||||
{
|
||||
Size sz = GetBaseTab()->GetSizeHint();
|
||||
if(!ctrl.IsFloating()) ctrl.ShowDragBar();
|
||||
ctrl.Remove();
|
||||
int id = tabs.Find(ctrl);
|
||||
if(id >= 0) tabs.Close(id);
|
||||
else if(position >= 0) tabs.Close(position);
|
||||
childcount--;
|
||||
ReposChilds();
|
||||
ctrl.SetSizeHint(sz);
|
||||
RemoveTabWindow();
|
||||
reinterpret_cast<DockWindow&>(ctrl).SetOwnerTab(NULL);
|
||||
GetBase().RefreshPanel();
|
||||
position = -1;
|
||||
}
|
||||
|
||||
void TabWindow::DetachAll()
|
||||
{
|
||||
if(IsDestroyed()) return;
|
||||
Shut();
|
||||
DockableCtrl *childctrl = NULL;
|
||||
Vector<DockableCtrl*> childs;
|
||||
childs.Clear();
|
||||
int i = 0;
|
||||
int nest = GetNestLevel();
|
||||
for(i = 0; i < ChildCount(); i++)
|
||||
{
|
||||
childctrl = GetChildAt(i + 1);
|
||||
if(childctrl) childs.Add(childctrl);
|
||||
}
|
||||
int ncount = childs.GetCount();
|
||||
i = 0;
|
||||
for(i = 0; i < (ncount * 2); i++)
|
||||
{
|
||||
if(i < ncount)
|
||||
{
|
||||
childctrl = childs.At(i);
|
||||
ASSERT(childctrl);
|
||||
if(childctrl->IsTabWindow()) dynamic_cast<TabWindow*>(childctrl)->DetachAll();
|
||||
}
|
||||
else
|
||||
{
|
||||
childctrl = childs.At(i - ncount);
|
||||
ASSERT(childctrl);
|
||||
childctrl->Shut();
|
||||
}
|
||||
}
|
||||
Remove();
|
||||
RemoveFrame(tabs);
|
||||
SetOwnerTab(NULL);
|
||||
childcount = 0;
|
||||
destroyed = true;
|
||||
GetBase().RefreshPanel();
|
||||
}
|
||||
|
||||
bool TabWindow::RemoveTabWindow()
|
||||
{
|
||||
bool tabbed = false;
|
||||
TabWindow *tabwindow = NULL;
|
||||
ReSize();
|
||||
Size sizehint = GetBaseTab()->GetSizeHint();
|
||||
|
||||
if(ChildCount() == 1)
|
||||
{
|
||||
DockWindow* lastctrl = reinterpret_cast<DockWindow*>(GetChildAt(1));
|
||||
tabs.CloseAll();
|
||||
RemoveFrame(tabs);
|
||||
if(lastctrl)
|
||||
{
|
||||
int a = Alignment();
|
||||
int s = State();
|
||||
int p = Position();
|
||||
|
||||
lastctrl->Remove();
|
||||
childcount = 0;
|
||||
if(IsShut()) lastctrl->Shut();
|
||||
if(IsTabbed())
|
||||
{
|
||||
TabInterface& tabs = GetOwnerTab()->GetTabs();
|
||||
GetOwnerTab()->Attach(*lastctrl);
|
||||
Shut();
|
||||
}
|
||||
else if(IsFloating())
|
||||
{
|
||||
lastctrl->Shut();
|
||||
SetRect(GetBaseTab()->GetScreenRect());
|
||||
Rect r = GetRect();
|
||||
lastctrl->OpenWindow(r);
|
||||
lastctrl->DockingStyle(DOCK_NONE, STATE_SHOW, 0);
|
||||
Shut();
|
||||
lastctrl->SetOwnerTab(NULL);
|
||||
}
|
||||
else
|
||||
{
|
||||
Shut();
|
||||
lastctrl->ShowDragBar();
|
||||
lastctrl->SetSizeHint(sizehint);
|
||||
lastctrl->Dock(a, s, p);
|
||||
lastctrl->SetOwnerTab(NULL);
|
||||
}
|
||||
DockingStyle(DOCK_NONE, STATE_SHUT, 0);
|
||||
return destroyed = true;
|
||||
}
|
||||
}
|
||||
if(GetActiveCtrl()) RefreshTabWindowLabel(*GetActiveCtrl());
|
||||
return false;
|
||||
}
|
||||
|
||||
DockableCtrl* TabWindow::GetChildAt(int position)
|
||||
{
|
||||
for(Ctrl* c = Ctrl::GetFirstChild(); c; c = c->GetNext())
|
||||
{
|
||||
DockableCtrl* ctrl = dynamic_cast<DockableCtrl*>(c);
|
||||
if(ctrl) if(ctrl->Position() == position)
|
||||
return ctrl;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void TabWindow::ReposChilds()
|
||||
{
|
||||
int i = 0;
|
||||
for(Ctrl* c = Ctrl::GetFirstChild(); c; c = c->GetNext())
|
||||
{
|
||||
DockableCtrl* ctrl = dynamic_cast<DockableCtrl*>(c);
|
||||
if(ctrl) ctrl->Posit(++i);
|
||||
}
|
||||
}
|
||||
|
||||
TabWindow* TabWindow::GetBaseTab()
|
||||
{
|
||||
TabWindow *to = GetOwnerTab();
|
||||
TabWindow *tb = NULL;
|
||||
if(!IsTabbed() || !to) return this;
|
||||
while(to)
|
||||
{
|
||||
tb = to;
|
||||
to = to->GetOwnerTab();
|
||||
}
|
||||
ASSERT(tb);
|
||||
return tb;
|
||||
}
|
||||
|
||||
void TabWindow::OnMenuButton()
|
||||
{
|
||||
DockWindow::OnMenuButton();
|
||||
if(IsShut()) DetachAll();
|
||||
}
|
||||
|
||||
void TabWindow::OnShutButton()
|
||||
{
|
||||
DetachAll();
|
||||
Shut();
|
||||
}
|
||||
|
||||
void TabWindow::OnAutoHideButton()
|
||||
{
|
||||
DockWindow::OnAutoHideButton();
|
||||
}
|
||||
|
||||
void TabWindow::OnShutWindow()
|
||||
{
|
||||
OnShutButton();
|
||||
}
|
||||
|
||||
|
||||
void TabWindow::StartTabAnimation()
|
||||
{
|
||||
if(IsTabAnimating()) return;
|
||||
childcount++;
|
||||
String title = t_("Tabbed Window");
|
||||
|
||||
Size canvassize = GetSize();
|
||||
ImageDraw canvas(canvassize.cx, canvassize.cy);
|
||||
GetActiveCtrl()->DrawCtrlWithParent(canvas, 0, 0);
|
||||
canvas.DrawImage(canvassize, GetStyle()->tabhighlight);
|
||||
|
||||
previous = GetActiveTab();
|
||||
GetBase().RefreshWidgetLayout();
|
||||
tabs.Add(title, true);
|
||||
SetLabel(title);
|
||||
|
||||
animimage = canvas;
|
||||
animating = true;
|
||||
}
|
||||
|
||||
void TabWindow::StopTabAnimation()
|
||||
{
|
||||
if(!IsTabAnimating()) return;
|
||||
tabs.Close(tabs.GetActiveTab());
|
||||
childcount--;
|
||||
animating = false;
|
||||
animimage.Clear();
|
||||
if(!RemoveTabWindow())
|
||||
{
|
||||
SetActive(previous);
|
||||
if(GetActiveTab())
|
||||
SetLabel(GetTabs()
|
||||
.GetTabs()
|
||||
.At(GetActiveTab()).dock->GetLabel());
|
||||
return;
|
||||
}
|
||||
position = -1;
|
||||
}
|
||||
|
||||
|
||||
bool TabWindow::HasCtrlInRange()
|
||||
{
|
||||
Rect r = GetCtrlRect();
|
||||
int hrange = r.Width() / 3;
|
||||
int vrange = r.Height() / 3;
|
||||
return Rect(r.left + hrange, r.top + vrange, r.right - hrange, r.bottom - vrange).Contains(GetMousePos());
|
||||
}
|
||||
|
||||
bool TabWindow::HasTabbedDock()
|
||||
{
|
||||
return (bool) ChildCount();
|
||||
}
|
||||
|
||||
int TabWindow::ChildCount()
|
||||
{
|
||||
return childcount;
|
||||
}
|
||||
|
||||
void TabWindow::SetNestLevel(int n)
|
||||
{
|
||||
nestlevel = n;
|
||||
}
|
||||
|
||||
void TabWindow::SetActive(int index)
|
||||
{
|
||||
if(index >= ChildCount()) return;
|
||||
if(index != GetActiveTab()) tabs.SetActiveTab(index);
|
||||
|
||||
for(int i = 0; i < tabs.GetTabs().GetCount(); i++)
|
||||
{
|
||||
TabInterface::Tab t = tabs.GetTabs().At(i);
|
||||
if(t.dock)
|
||||
{
|
||||
if(i == index) t.dock->Ctrl::Show();
|
||||
else t.dock->Ctrl::Hide();
|
||||
}
|
||||
}
|
||||
RefreshTabWindowLabel(*this);
|
||||
}
|
||||
|
||||
void TabWindow::SetActive(DockableCtrl& ctrl)
|
||||
{
|
||||
}
|
||||
|
||||
int TabWindow::GetActiveTab()
|
||||
{
|
||||
return tabs.GetActiveTab();
|
||||
}
|
||||
|
||||
DockableCtrl* TabWindow::GetActiveCtrl()
|
||||
{
|
||||
return GetChildAt(GetActiveTab() + 1);
|
||||
}
|
||||
|
||||
void TabWindow::OnActiveTab()
|
||||
{
|
||||
if(!IsTabAnimating()) SetActive(tabs.GetActiveTab());
|
||||
}
|
||||
|
||||
void TabWindow::OnTabClose(int id, DockableCtrl& ctrl)
|
||||
{
|
||||
position = id;
|
||||
ctrl.Shut();
|
||||
}
|
||||
|
||||
void TabWindow::OnTabDrag(int id, DockableCtrl& ctrl)
|
||||
{
|
||||
position = id;
|
||||
ctrl.StartWindowDrag();
|
||||
}
|
||||
|
||||
void TabWindow::OnTabContextMenu(int id, DockableCtrl& ctrl)
|
||||
{
|
||||
position = id;
|
||||
reinterpret_cast<DockWindow&>(ctrl).OnMenuButton();
|
||||
}
|
||||
|
||||
void TabWindow::OnTabActive(int id, DockableCtrl& ctrl)
|
||||
{
|
||||
position = id;
|
||||
RefreshTabWindowLabel(ctrl);
|
||||
}
|
||||
|
||||
void TabWindow::RefreshTabWindowLabel(DockableCtrl& ctrl)
|
||||
{
|
||||
int id = 0;
|
||||
AutoHideBar* hidebar = NULL;
|
||||
TabWindow* tabwindow = NULL;
|
||||
|
||||
if(IsTabbed())
|
||||
{
|
||||
TabWindow* tabwindow = GetOwnerTab();
|
||||
while(tabwindow)
|
||||
{
|
||||
int id = tabwindow->GetActiveTab();
|
||||
if(id < 0) break;
|
||||
TabInterface::Tab& sourcetab = GetTabs().GetTabs().At(GetActiveTab());
|
||||
TabInterface::Tab& targettab = tabwindow->GetTabs().GetTabs().At(id);
|
||||
String& label = targettab.name = sourcetab.name;
|
||||
Image& icon = targettab.icon = sourcetab.icon;
|
||||
tabwindow->GetTabs().ReposTabs();
|
||||
if(!tabwindow->GetOwnerTab())
|
||||
{
|
||||
if(tabwindow->IsAutoHidden())
|
||||
{
|
||||
hidebar = tabwindow->GetOwnerBar();
|
||||
id = hidebar->Find((DockableCtrl&)*tabwindow);
|
||||
if(id >= 0)
|
||||
{
|
||||
TabInterface::Tab& t = hidebar->GetTabs().At(id);
|
||||
t.name = label;
|
||||
t.icon = icon;
|
||||
hidebar->ReposTabs();
|
||||
hidebar->Refresh();
|
||||
}
|
||||
|
||||
}
|
||||
tabwindow->SetLabel(label);
|
||||
tabwindow->SetIcon (icon);
|
||||
}
|
||||
tabwindow->RefreshLayoutDeep();
|
||||
tabwindow = tabwindow->GetOwnerTab();
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
if(IsAutoHidden())
|
||||
{
|
||||
hidebar = GetOwnerBar();
|
||||
id = hidebar->Find((DockableCtrl&)*this);
|
||||
if(id >= 0)
|
||||
{
|
||||
TabInterface::Tab& t = hidebar->GetTabs().At(id);
|
||||
t.name = ctrl.GetLabel();
|
||||
t.icon = ctrl.GetIcon();
|
||||
hidebar->ReposTabs();
|
||||
hidebar->Refresh();
|
||||
}
|
||||
}
|
||||
DockableCtrl::SetLabel(ctrl.GetLabel());
|
||||
DockableCtrl::SetIcon(ctrl.GetIcon());
|
||||
GetTabs().ReposTabs();
|
||||
RefreshLayoutDeep();
|
||||
}
|
||||
}
|
||||
|
||||
void TabWindow::Paint(Draw& d)
|
||||
{
|
||||
IsTabAnimating() ? d.DrawImage(GetSize(), animimage) : TopWindow::Paint(d);
|
||||
}
|
||||
|
||||
void TabWindow::Serialize(Stream& s)
|
||||
{
|
||||
int type = 0;
|
||||
int alignment = 0;
|
||||
int state = 0;
|
||||
int position = 0;
|
||||
int id = 0;
|
||||
int childcount = 0;
|
||||
int activetab = 0;
|
||||
Size newsize;
|
||||
Rect r = GetRect();
|
||||
|
||||
if(s.IsStoring())
|
||||
{
|
||||
ReSize();
|
||||
type = TYPE_TABWINDOW;
|
||||
alignment = GetBaseTab()->Alignment();
|
||||
state = GetBaseTab()->State();
|
||||
position = GetBaseTab()->Position();
|
||||
id = 0;
|
||||
newsize = GetBaseTab()->GetSizeHint();
|
||||
childcount = ChildCount();
|
||||
activetab = GetActiveTab();
|
||||
|
||||
s / type;
|
||||
s / id;
|
||||
s / alignment / state / position;
|
||||
newsize.Serialize(s);
|
||||
s / childcount;
|
||||
s / activetab;
|
||||
s % groupwindow;
|
||||
s / groupname;
|
||||
if(!GetOwnerTab() && IsFloating())
|
||||
{
|
||||
r.Serialize(s);
|
||||
SerializePlacement(s, true);
|
||||
}
|
||||
|
||||
for(int i = 0; i < childcount; i++)
|
||||
GetChildAt(i + 1)->Serialize(s);
|
||||
}
|
||||
if(s.IsLoading())
|
||||
{
|
||||
TabWindow* tabwindow = GetOwnerTab();
|
||||
s / alignment / state / position;
|
||||
newsize.Serialize(s);
|
||||
s / childcount;
|
||||
s / activetab;
|
||||
s % groupwindow;
|
||||
s / groupname;
|
||||
|
||||
if(!tabwindow)
|
||||
{
|
||||
if(alignment == DOCK_NONE && state != STATE_SHUT)
|
||||
{
|
||||
r.Serialize(s);
|
||||
FloatEx(Rect(r.left, r.top, 10, 10));
|
||||
SerializePlacement(s, true);
|
||||
}
|
||||
else
|
||||
{
|
||||
Shut();
|
||||
SetSize(newsize);
|
||||
Dock(alignment, state, position, false);
|
||||
}
|
||||
}
|
||||
else tabwindow->Attach(*this);
|
||||
|
||||
for(int i = 0; i < childcount; i++)
|
||||
{
|
||||
s / type / id;
|
||||
if(type == TYPE_DOCKWINDOW)
|
||||
{
|
||||
DockWindow* child = dynamic_cast<DockWindow*>(GetBase().GetCtrlRecordFromId(id)->ctrl);
|
||||
ASSERT(child);
|
||||
child->SetOwnerTab(this);
|
||||
child->Serialize(s);
|
||||
}
|
||||
if(type == TYPE_TABWINDOW)
|
||||
{
|
||||
TabWindow* tabwindow = GetBase().GetPaneFrame(0).AddTabWindow();
|
||||
tabwindow->SetOwnerTab(this);
|
||||
tabwindow->Serialize(s);
|
||||
}
|
||||
}
|
||||
SetActive(activetab);
|
||||
}
|
||||
}
|
||||
246
archive/DockCtrl/DockableCtrl.cpp
Normal file
246
archive/DockCtrl/DockableCtrl.cpp
Normal file
|
|
@ -0,0 +1,246 @@
|
|||
#include "DockCtrl/DockCtrl.h"
|
||||
|
||||
#define IMAGEFILE <DockCtrl/DockableCtrl.iml>
|
||||
#define IMAGECLASS DockableCtrlImages
|
||||
#include <Draw/iml.h>
|
||||
|
||||
//===============================================
|
||||
// DockableCtrl class:
|
||||
// Base class of all DockCtrl widgets.
|
||||
//===============================================
|
||||
|
||||
DockableCtrl::DockableCtrl()
|
||||
{
|
||||
DockingStyle(DOCK_NONE, STATE_SHUT, 0);
|
||||
PermitDragAndDrop();
|
||||
SetDropTarget();
|
||||
docksize.Clear();
|
||||
hasdragbar = false;
|
||||
haschildbar = false;
|
||||
isdragged = false;
|
||||
isdraggable = true;
|
||||
dockbase = NULL;
|
||||
style = NULL;
|
||||
WhenClose = THISBACK(OnShutWindow);
|
||||
NoCenter().BackPaint();
|
||||
}
|
||||
|
||||
DockableCtrl::~DockableCtrl()
|
||||
{
|
||||
}
|
||||
|
||||
DockableCtrl& DockableCtrl::DockingStyle(int alignment, int state, int position)
|
||||
{
|
||||
dockalignment = alignment;
|
||||
dockstate = state;
|
||||
dockposition = position;
|
||||
return *this;
|
||||
}
|
||||
|
||||
DockableCtrl& DockableCtrl::SetLabel(String title)
|
||||
{
|
||||
IsNull(title) || title == t_("") ? dockname = t_("Untitled") : dockname = title;
|
||||
Title(title);
|
||||
if(IsVisible()) Refresh();
|
||||
return *this;
|
||||
}
|
||||
|
||||
DockableCtrl& DockableCtrl::SetIcon(Image icon)
|
||||
{
|
||||
dockicon = icon;
|
||||
Icon(dockicon);
|
||||
if(IsVisible()) Refresh();
|
||||
return *this;
|
||||
}
|
||||
|
||||
DockableCtrl& DockableCtrl::SetSize(Size sz)
|
||||
{
|
||||
SetSizeHint(sz);
|
||||
Rect r = GetRect();
|
||||
SetRect(r.left, r.top, r.left + sz.cx, r.top + sz.cy);
|
||||
if(IsFloating()) Refresh();
|
||||
else RefreshParentLayout();
|
||||
return *this;
|
||||
}
|
||||
|
||||
void DockableCtrl::ReSize()
|
||||
{
|
||||
docksize = Ctrl::GetSize();
|
||||
for(int i = 0; i < GetFrameCount(); i++) Ctrl::GetFrame(i).FrameAddSize(docksize);
|
||||
}
|
||||
|
||||
void DockableCtrl::Layout()
|
||||
{
|
||||
TopWindow::Layout();
|
||||
if(IsFloating() && IsOpen()) ReSize();
|
||||
}
|
||||
|
||||
void DockableCtrl::OpenWindow(Rect& r)
|
||||
{
|
||||
if(IsPopUp()) Close();
|
||||
if(IsOpen()) return;
|
||||
ReSize();
|
||||
r.right = r.left + docksize.cx;
|
||||
r.bottom = r.top + docksize.cy;
|
||||
HideDragBar();
|
||||
Title(GetLabel());
|
||||
SetRect(r);
|
||||
Ctrl::Hide();
|
||||
Open(GetOwner());
|
||||
Ctrl::Show();
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void DockableCtrl::OpenWindow(int x, int y, int cx, int cy)
|
||||
{
|
||||
if(IsPopUp()) Close();
|
||||
if(IsOpen()) return;
|
||||
HideDragBar();
|
||||
Title(GetLabel());
|
||||
SetRect(x, y, cx, cy);
|
||||
Ctrl::Hide();
|
||||
Open(GetOwner());
|
||||
Ctrl::Show();
|
||||
Refresh();
|
||||
}
|
||||
|
||||
void DockableCtrl::ShutWindow()
|
||||
{
|
||||
if(IsPopUp()) Close();
|
||||
ReSize();
|
||||
if(!IsOpen() || !IsFloating()) return;
|
||||
Rect r = GetRect();
|
||||
r.right = r.left + docksize.cx;
|
||||
r.bottom = r.top + docksize.cy;
|
||||
Close();
|
||||
Remove();
|
||||
SetRect(r);
|
||||
ShowDragBar();
|
||||
}
|
||||
|
||||
void DockableCtrl::OnShutWindow()
|
||||
{
|
||||
Shut();
|
||||
}
|
||||
|
||||
void DockableCtrl::ContextMenu()
|
||||
{
|
||||
MenuBar::Execute(WhenContextMenu);
|
||||
}
|
||||
|
||||
void DockableCtrl::Settings()
|
||||
{
|
||||
GetBase().ControlPanel();
|
||||
}
|
||||
|
||||
void DockableCtrl::Menu()
|
||||
{
|
||||
ContextMenu();
|
||||
}
|
||||
|
||||
void DockableCtrl::StartWindowDrag()
|
||||
{
|
||||
if(!isdraggable) return;
|
||||
Point pt = GetMousePos();
|
||||
Float();
|
||||
|
||||
// Thanks to mrjt (James Thomas) for the X11 window drag code.
|
||||
#if defined(PLATFORM_WIN32)
|
||||
SendMessage(GetHWND(), WM_NCLBUTTONDOWN, 2, MAKELONG(pt.x, pt.y));
|
||||
#elif defined(PLATFORM_X11)
|
||||
Atom xwndDrag = XAtom("_NET_WM_MOVERESIZE");
|
||||
XEvent e;
|
||||
Zero(e);
|
||||
e.xclient.type = ClientMessage;
|
||||
e.xclient.message_type = xwndDrag;
|
||||
e.xclient.window = GetWindow();
|
||||
e.xclient.format = 32;
|
||||
e.xclient.display = Xdisplay;
|
||||
e.xclient.send_event = XTrue;
|
||||
e.xclient.data.l[0] = pt.x;
|
||||
e.xclient.data.l[1] = pt.y;
|
||||
e.xclient.data.l[2] = 8;
|
||||
e.xclient.data.l[3] = 1;
|
||||
e.xclient.data.l[4] = 0;
|
||||
|
||||
XUngrabPointer(Xdisplay, CurrentTime);
|
||||
XSendEvent(Xdisplay, RootWindow(Xdisplay, Xscreenno), XFalse, SubstructureNotifyMask, &e);
|
||||
XFlush(Xdisplay);
|
||||
#endif
|
||||
}
|
||||
|
||||
|
||||
#if defined(PLATFORM_WIN32)
|
||||
LRESULT DockableCtrl::WindowProc(UINT message, WPARAM wParam, LPARAM lParam)
|
||||
{
|
||||
if(IsFloating())
|
||||
{
|
||||
switch(message)
|
||||
{
|
||||
case WM_MOVING:
|
||||
if(!isdraggable) break;
|
||||
isdragged = true;
|
||||
SetDropTarget(DOCK_NONE, GetDropState());
|
||||
GetBase().DoDragAndDrop(*this, GetMousePos(), GetCtrlSize());
|
||||
break;
|
||||
|
||||
case WM_EXITSIZEMOVE:
|
||||
if(!isdraggable) break;
|
||||
if(!GetMouseLeft() && HasDropTarget() && isdragged)
|
||||
{
|
||||
Dock(GetDropTarget(), GetDropState(), Position());
|
||||
Refresh();
|
||||
SetDropTarget();
|
||||
isdragged = false;
|
||||
}
|
||||
break;
|
||||
|
||||
case WM_NCRBUTTONDOWN:
|
||||
ContextMenu();
|
||||
return 1L;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
return TopWindow::WindowProc(message, wParam, lParam);
|
||||
}
|
||||
#elif defined(PLATFORM_X11)
|
||||
void DockableCtrl::EventProc(XWindow& w, XEvent *event)
|
||||
{
|
||||
if (IsOpen())
|
||||
{
|
||||
switch(event->type) {
|
||||
case ConfigureNotify:
|
||||
{
|
||||
if(!isdraggable) break;
|
||||
XConfigureEvent& e = event->xconfigure;
|
||||
if (Point(e.x, e.y) != GetScreenRect().TopLeft())
|
||||
{
|
||||
SetDropTarget(DOCK_NONE, GetDropState());
|
||||
if(!isdragged);
|
||||
{
|
||||
isdragged = true;
|
||||
GetBase().DoDragAndDrop(*this, GetMousePos(), GetCtrlSize());
|
||||
SetFocus();
|
||||
}
|
||||
break;
|
||||
}
|
||||
break;
|
||||
}
|
||||
case FocusIn:
|
||||
if(!isdraggable) break;
|
||||
XFocusChangeEvent &e = event->xfocus;
|
||||
if (e.mode == NotifyUngrab)
|
||||
{
|
||||
Dock(GetDropTarget(), GetDropState(), Position());
|
||||
SetDropTarget();
|
||||
isdragged = false;
|
||||
return;
|
||||
}
|
||||
break;
|
||||
}
|
||||
}
|
||||
TopWindow::EventProc(w, event);
|
||||
}
|
||||
#endif
|
||||
114
archive/DockCtrl/DockableCtrl.iml
Normal file
114
archive/DockCtrl/DockableCtrl.iml
Normal file
|
|
@ -0,0 +1,114 @@
|
|||
PREMULTIPLIED
|
||||
IMAGE_ID(DragArrow)
|
||||
IMAGE_ID(DBarBackground)
|
||||
IMAGE_ID(EBarBackground)
|
||||
IMAGE_ID(CBarBackground)
|
||||
IMAGE_ID(DefaultImage)
|
||||
IMAGE_ID(Logo)
|
||||
IMAGE_ID(DClose)
|
||||
IMAGE_ID(DCloseh)
|
||||
IMAGE_ID(DCloses)
|
||||
IMAGE_ID(DMenu)
|
||||
IMAGE_ID(DMenuh)
|
||||
IMAGE_ID(DMenus)
|
||||
IMAGE_ID(DHide)
|
||||
IMAGE_ID(DHideh)
|
||||
IMAGE_ID(DHides)
|
||||
IMAGE_ID(CClose)
|
||||
IMAGE_ID(CCloseh)
|
||||
IMAGE_ID(CClosep)
|
||||
IMAGE_ID(CHide)
|
||||
IMAGE_ID(CHideh)
|
||||
IMAGE_ID(CHides)
|
||||
IMAGE_ID(CMenu)
|
||||
IMAGE_ID(CMenuh)
|
||||
IMAGE_ID(CMenus)
|
||||
|
||||
IMAGE_BEGIN_DATA
|
||||
IMAGE_DATA(120,156,237,155,11,80,84,215,25,199,111,39,73,199,81,90,173,154,210,142,157,106,19,157,118,236,76,212,105,199,36,19)
|
||||
IMAGE_DATA(34,129,17,35,58,160,196,71,139,25,197,153,132,40,26,181,145,212,74,170,17,67,170,121,72,53,38,90,235,27,229,37)
|
||||
IMAGE_DATA(4,69,64,144,151,203,67,80,16,65,141,8,187,242,92,222,32,239,40,226,163,255,126,231,176,7,151,117,239,189,187,43)
|
||||
IMAGE_DATA(70,137,30,230,239,121,125,191,123,206,249,206,185,187,223,189,130,244,156,244,83,201,76,130,105,29,61,109,48,174,195,168)
|
||||
IMAGE_DATA(221,144,75,166,185,105,217,108,219,79,164,95,208,191,67,120,169,179,179,19,29,29,29,104,107,107,227,106,105,105,65,115)
|
||||
IMAGE_DATA(115,51,154,154,154,184,26,26,26,80,95,95,207,85,91,91,139,154,154,26,84,85,85,113,85,86,86,162,162,162,2,134)
|
||||
IMAGE_DATA(11,138,169,2,119,239,222,65,119,247,45,124,127,253,58,218,218,219,209,116,173,25,53,181,245,40,175,212,67,123,181,20)
|
||||
IMAGE_DATA(151,10,139,144,87,112,9,217,57,121,208,156,206,70,210,169,12,156,56,153,138,232,184,147,136,60,118,162,239,5,253,253)
|
||||
IMAGE_DATA(253,241,160,146,134,209,143,137,191,173,149,9,255,169,21,122,24,188,85,73,137,183,197,23,16,201,198,181,244,51,111,181)
|
||||
IMAGE_DATA(47,250,149,183,38,245,23,111,110,47,172,224,251,172,103,160,243,86,235,231,244,163,146,236,73,163,141,52,66,198,110,40)
|
||||
IMAGE_DATA(201,209,72,5,227,199,143,199,36,210,132,158,193,18,140,250,134,26,113,142,47,190,248,34,188,188,188,184,236,237,237,17)
|
||||
IMAGE_DATA(30,30,142,18,31,31,104,136,99,125,115,230,204,193,168,81,163,96,96,123,57,102,15,104,72,27,224,232,56,26,153,115)
|
||||
IMAGE_DATA(231,2,67,37,104,188,36,186,214,4,20,20,108,133,131,131,131,12,183,129,185,144,56,9,229,204,241,145,196,105,24,199)
|
||||
IMAGE_DATA(242,55,48,113,226,68,99,142,249,160,128,205,141,141,195,152,161,52,78,121,152,132,58,186,198,4,226,236,237,41,159,48)
|
||||
IMAGE_DATA(12,118,118,118,140,43,16,126,99,62,96,235,17,98,245,242,114,9,180,26,72,26,54,190,99,159,62,225,103,54,126,90)
|
||||
IMAGE_DATA(90,90,175,248,124,136,147,240,26,113,26,76,159,62,189,111,159,129,27,59,118,44,182,109,219,214,43,86,151,202,95,134)
|
||||
IMAGE_DATA(212,69,171,221,170,193,228,201,147,251,246,221,219,211,132,158,125,152,192,125,192,214,35,149,151,67,250,146,29,52,13,237)
|
||||
IMAGE_DATA(131,132,55,223,252,21,134,15,31,46,246,82,156,3,71,182,63,204,215,204,111,204,7,210,170,114,242,195,109,154,99,24)
|
||||
IMAGE_DATA(103,14,28,88,108,234,79,206,177,61,101,251,195,250,122,252,86,142,141,27,47,243,185,177,113,88,187,97,60,99,238,190)
|
||||
IMAGE_DATA(115,38,73,47,115,91,195,122,228,206,153,105,82,63,215,198,55,199,202,21,203,253,119,124,189,61,54,77,147,138,148,228)
|
||||
IMAGE_DATA(68,69,105,82,147,193,108,5,147,145,174,129,182,248,10,202,74,175,162,180,68,103,86,172,239,170,174,24,204,182,103,156)
|
||||
IMAGE_DATA(20,92,40,200,195,165,139,249,184,120,225,188,162,132,77,106,74,34,23,227,10,242,207,113,157,207,203,225,125,249,231,115)
|
||||
IMAGE_DATA(123,219,140,197,108,51,210,79,245,225,152,109,69,121,9,234,106,171,122,217,154,234,74,46,102,35,148,158,150,138,248,248)
|
||||
IMAGE_DATA(88,156,167,254,60,26,39,159,216,106,178,169,37,142,229,149,149,101,188,204,148,155,123,6,233,52,206,185,115,103,145,66)
|
||||
IMAGE_DATA(99,29,139,138,196,185,156,51,200,57,147,133,179,217,167,121,174,175,40,67,181,190,162,87,204,143,113,49,209,72,56,17)
|
||||
IMAGE_DATA(203,21,19,125,20,145,17,97,200,57,155,133,51,217,153,92,217,89,25,228,63,45,244,52,22,19,155,119,114,82,2,18)
|
||||
IMAGE_DATA(79,158,224,121,74,242,73,28,59,26,137,208,144,67,220,62,235,116,58,103,174,234,138,200,231,58,46,81,102,215,17,190)
|
||||
IMAGE_DATA(208,156,74,70,212,183,71,112,248,208,1,110,127,58,51,141,247,125,119,169,128,219,179,235,198,197,70,211,190,22,114,177)
|
||||
IMAGE_DATA(253,98,12,203,217,28,15,7,29,192,233,140,52,100,210,126,38,39,38,240,245,178,156,173,131,229,241,113,49,136,61,126)
|
||||
IMAGE_DATA(12,41,73,39,145,118,42,5,233,116,174,190,141,160,15,130,176,96,62,254,169,212,36,36,144,111,79,196,29,71,252,137)
|
||||
IMAGE_DATA(24,190,30,54,38,107,103,253,98,60,182,7,33,193,65,252,204,28,9,15,225,117,227,185,176,58,155,119,102,134,166,143)
|
||||
IMAGE_DATA(142,71,71,245,57,163,225,161,193,124,189,230,116,52,42,130,43,44,244,112,47,115,223,55,199,154,119,223,241,215,190,179)
|
||||
IMAGE_DATA(4,133,110,30,138,42,122,219,11,204,86,48,186,101,43,208,114,58,7,29,133,87,209,113,89,107,94,212,215,150,91,0)
|
||||
IMAGE_DATA(157,207,251,156,45,246,94,138,218,195,81,168,139,136,67,109,120,76,143,66,143,223,43,135,25,68,229,186,35,177,148,199)
|
||||
IMAGE_DATA(226,202,188,5,184,60,123,30,106,14,71,163,122,223,17,46,253,127,130,201,238,56,170,246,132,161,106,111,56,170,247,71)
|
||||
IMAGE_DATA(112,241,50,179,9,138,66,241,210,21,40,156,61,151,184,99,212,71,204,174,96,124,95,86,137,219,55,187,232,186,199,169)
|
||||
IMAGE_DATA(126,24,55,219,218,185,170,15,18,127,48,18,213,135,142,66,235,189,28,217,238,179,120,189,106,79,8,170,67,142,162,187)
|
||||
IMAGE_DATA(235,6,110,223,190,133,91,148,119,93,187,198,203,76,101,255,61,132,146,21,31,163,122,103,16,242,223,243,65,140,235,12)
|
||||
IMAGE_DATA(212,236,14,129,126,199,1,84,108,223,135,194,160,96,220,164,7,136,91,221,221,189,202,216,180,5,249,14,110,208,189,62)
|
||||
IMAGE_DATA(31,37,14,115,145,58,195,3,135,92,166,161,246,171,93,208,7,126,77,218,142,202,205,129,104,161,167,148,174,27,93,92)
|
||||
IMAGE_DATA(29,173,173,184,178,192,27,85,83,104,61,46,158,104,32,197,186,186,99,187,179,51,234,200,86,31,240,25,244,255,250,28)
|
||||
IMAGE_DATA(141,244,112,210,216,212,140,107,205,173,168,171,169,165,167,31,122,10,170,107,192,53,111,95,180,185,204,67,135,171,39,34)
|
||||
IMAGE_DATA(166,207,64,192,20,7,212,249,173,135,126,141,31,202,124,215,162,48,255,34,244,100,159,180,46,0,241,127,89,132,178,138)
|
||||
IMAGE_DATA(74,148,144,202,188,87,161,221,101,62,58,137,219,63,213,5,254,142,14,104,88,190,18,85,180,159,87,60,22,35,194,197)
|
||||
IMAGE_DATA(29,113,126,31,227,146,195,44,62,183,120,175,37,136,92,248,30,170,157,61,208,238,250,215,30,206,197,5,159,207,114,67)
|
||||
IMAGE_DATA(153,199,66,232,61,188,112,225,117,79,228,190,234,137,252,215,230,145,15,60,81,227,228,137,102,231,249,104,32,181,211,186)
|
||||
IMAGE_DATA(218,72,157,174,11,176,201,201,137,159,153,111,166,57,161,105,174,7,234,151,185,163,102,165,59,26,254,230,142,230,213,238)
|
||||
IMAGE_DATA(104,247,117,199,245,191,187,225,134,208,135,179,112,116,142,75,159,51,250,137,171,11,246,206,116,193,238,153,83,177,219,109)
|
||||
IMAGE_DATA(42,246,80,190,207,221,25,251,221,122,116,144,202,155,28,157,122,153,251,110,142,157,190,171,67,115,126,55,6,233,20,106)
|
||||
IMAGE_DATA(40,41,235,249,231,193,108,5,147,107,55,18,245,161,209,104,201,56,135,22,77,174,121,81,95,83,116,34,114,7,143,224)
|
||||
IMAGE_DATA(236,217,49,99,80,226,27,128,210,245,255,70,233,71,95,246,104,237,23,247,202,126,6,177,242,186,64,202,3,145,57,120)
|
||||
IMAGE_DATA(48,50,104,252,18,223,205,208,250,172,227,42,242,250,144,236,190,64,177,183,31,221,4,255,132,118,217,122,46,94,166,126)
|
||||
IMAGE_DATA(221,7,1,56,59,104,36,50,5,71,125,69,139,255,129,206,139,69,248,31,61,241,178,235,23,45,94,131,91,45,173,92)
|
||||
IMAGE_DATA(186,149,254,208,173,218,8,221,234,77,200,125,102,4,162,136,43,165,107,104,151,248,161,100,237,102,220,161,67,205,18,99)
|
||||
IMAGE_DATA(187,235,27,123,227,220,75,239,174,193,5,251,87,80,234,229,139,196,231,134,97,43,113,101,62,31,65,187,120,53,138,22)
|
||||
IMAGE_DATA(174,64,22,29,62,193,138,20,62,125,54,146,200,142,98,3,92,36,29,32,173,33,85,188,237,13,237,156,69,208,190,181)
|
||||
IMAGE_DATA(16,197,174,115,208,92,89,65,55,224,29,174,206,214,118,156,145,6,161,148,93,159,84,67,218,70,90,64,210,187,190,5)
|
||||
IMAGE_DATA(173,243,12,104,167,185,161,86,71,223,140,141,205,104,164,53,233,43,171,80,79,229,250,234,90,52,12,26,135,86,178,237)
|
||||
IMAGE_DATA(36,109,36,57,145,170,38,189,2,221,31,39,225,187,113,47,33,43,53,29,58,178,223,59,217,25,223,80,223,229,98,29)
|
||||
IMAGE_DATA(46,146,10,7,143,70,7,213,175,147,86,145,28,216,216,246,191,69,201,136,95,227,44,149,63,33,125,53,241,85,126,62)
|
||||
IMAGE_DATA(216,220,118,72,63,67,128,100,199,203,198,220,204,145,35,112,153,114,29,233,20,41,158,36,124,192,214,211,100,88,19,99)
|
||||
IMAGE_DATA(90,13,220,52,18,59,51,139,40,175,39,85,15,39,219,81,100,55,154,236,95,32,219,177,18,110,254,94,66,183,208,56)
|
||||
IMAGE_DATA(9,159,25,24,113,70,167,208,217,89,70,109,75,72,75,73,62,164,247,73,43,13,243,90,77,114,49,98,158,200,176,42)
|
||||
IMAGE_DATA(38,38,198,34,153,134,85,172,141,133,85,197,197,197,178,98,54,166,97,149,184,30,11,171,228,24,185,176,74,176,121,121)
|
||||
IMAGE_DATA(121,220,150,229,76,162,93,41,172,50,102,141,25,181,176,74,206,31,79,195,170,39,40,172,210,71,236,148,149,92,88,165)
|
||||
IMAGE_DATA(150,148,194,42,185,148,61,94,82,13,171,204,49,106,97,149,126,195,78,46,99,134,213,213,194,42,193,49,123,193,48,61)
|
||||
IMAGE_DATA(13,171,158,160,176,74,108,186,57,201,133,85,106,73,41,172,146,75,250,241,234,97,149,57,70,45,172,138,32,27,38,145)
|
||||
IMAGE_DATA(62,48,212,213,194,42,193,153,74,45,172,18,55,147,57,61,13,171,6,72,88,37,222,86,105,52,26,179,82,123,91,37)
|
||||
IMAGE_DATA(199,169,189,173,146,11,197,66,66,66,20,223,86,41,113,74,97,21,235,151,147,37,97,149,120,91,245,52,172,26,224,97)
|
||||
IMAGE_DATA(21,251,180,183,58,172,82,248,230,144,11,171,148,24,38,91,194,170,64,149,176,74,137,147,13,171,88,56,68,10,148,145)
|
||||
IMAGE_DATA(92,88,165,180,54,115,97,149,154,63,184,47,159,134,85,63,158,176,74,237,109,149,210,65,176,37,172,10,84,9,171,148)
|
||||
IMAGE_DATA(56,185,176,74,237,230,80,10,171,44,13,143,228,194,42,241,182,74,212,127,20,111,171,6,104,146,251,213,14,181,95,249)
|
||||
IMAGE_DATA(128,25,27,115,109,106,172,165,140,28,107,105,234,143,177,172,93,155,82,155,28,103,105,251,227,159,76,111,142,45,91,182)
|
||||
IMAGE_DATA(192,26,9,198,218,113,141,249,7,228,44,218,20,5,78,177,77,102,158,170,135,78,97,125,138,7,181,159,57,91,230,105)
|
||||
IMAGE_DATA(171,95,108,221,7,139,210,131,112,198,188,53,231,186,207,205,97,55,196,238,141,224,160,176,182,248,152,20,24,75,60,144)
|
||||
IMAGE_DATA(153,182,51,91,193,252,102,3,96,141,196,56,214,114,98,108,81,23,201,212,206,180,93,142,51,182,49,215,102,202,153,218)
|
||||
IMAGE_DATA(153,99,228,56,115,172,218,250,30,132,179,101,158,230,236,204,181,245,215,62,88,170,160,125,161,109,182,156,179,33,131,6)
|
||||
IMAGE_DATA(59,202,157,107,57,237,221,181,191,241,217,103,158,253,195,227,24,86,217,20,62,176,55,48,130,49,42,91,196,9,89,49)
|
||||
IMAGE_DATA(230,64,224,228,190,53,44,246,171,21,126,124,164,220,67,75,143,97,88,101,83,248,160,118,115,40,113,74,135,110,0,115)
|
||||
IMAGE_DATA(22,221,28,74,225,138,210,97,125,156,56,165,212,111,97,213,0,79,182,126,226,216,250,201,106,246,255,15,204,177,166,253)
|
||||
IMAGE_DATA(50,140,234,7,133,21,156,226,250,44,252,132,182,217,47,22,216,12,140,244,152,220,28,182,134,0,252,111,232,204,233,97)
|
||||
IMAGE_DATA(114,54,204,183,151,147,253,43,187,126,230,132,172,228,122,249,31,154,83,209,163,73,143,73,88,101,177,115,76,57,75,15)
|
||||
IMAGE_DATA(121,127,114,150,204,87,142,83,59,60,253,197,9,89,201,137,244,131,115,86,250,211,226,212,111,97,213,159,39,252,233,211)
|
||||
IMAGE_DATA(248,216,196,187,150,190,173,98,182,130,177,250,173,147,97,28,86,86,115,142,220,219,21,181,205,120,88,156,37,243,149,227)
|
||||
IMAGE_DATA(148,110,202,254,228,132,172,225,132,30,5,167,230,207,216,168,147,119,109,57,103,47,189,48,126,163,220,185,150,83,236,177)
|
||||
IMAGE_DATA(132,219,191,28,62,210,243,255,237,32,181,34,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
|
||||
IMAGE_END_DATA(2752, 24)
|
||||
666
archive/DockCtrl/PaneFrame.cpp
Normal file
666
archive/DockCtrl/PaneFrame.cpp
Normal file
|
|
@ -0,0 +1,666 @@
|
|||
#include "DockCtrl.h"
|
||||
|
||||
PaneFrame& PaneFrame::Attach(DockableCtrl& ctrl)
|
||||
{
|
||||
if(!GetBase().IsSideAllowed(GetType()))
|
||||
{
|
||||
// if not allowed, then find an allowed pane.
|
||||
for(int i = 0; i < 4; i++)
|
||||
if(GetBase().IsSideAllowed(i))
|
||||
{
|
||||
GetBase().Dock(ctrl.DockingStyle(i, ctrl.State(), 0));
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if(ctrl.IsTabbed())
|
||||
return AttachAsTab(ctrl);
|
||||
else if(ctrl.IsAutoHidden())
|
||||
return AttachAsAuto(ctrl);
|
||||
else if(ctrl.IsDocked())
|
||||
return AttachAsDock(ctrl);
|
||||
return *this;
|
||||
}
|
||||
|
||||
PaneFrame& PaneFrame::AttachAsDock(DockableCtrl& ctrl)
|
||||
{
|
||||
if(DnDHasSource())
|
||||
{
|
||||
int position = dndpos;
|
||||
DnDSourceoutofRange();
|
||||
if(dockcontainer.IsAnimating()) dockcontainer.StopAnimation();
|
||||
}
|
||||
if(ctrl.IsDocked() && !ctrl.IsHidden()) ShowFrame(ctrl.GetSizeHint());
|
||||
dockcontainer.AddChildDock(ctrl, dndpos ? dndpos : ctrl.Position());
|
||||
dndpos = 0;
|
||||
return RefreshPaneFrame();
|
||||
}
|
||||
|
||||
PaneFrame& PaneFrame::AttachAsTab(DockableCtrl& ctrl)
|
||||
{
|
||||
int position = ctrl.Position();
|
||||
if(DnDHasSource())
|
||||
{
|
||||
position = dndpos;
|
||||
DnDSourceoutofRange();
|
||||
if(HasTabWindow(GetActiveTabWindow()))
|
||||
if(GetActiveTabWindow()->IsTabAnimating())
|
||||
GetActiveTabWindow()->StopTabAnimation();
|
||||
}
|
||||
else
|
||||
{
|
||||
DockableCtrl* targetctrl = dockcontainer.GetChildAt(position);
|
||||
|
||||
if(!targetctrl)
|
||||
{
|
||||
int cc = dockcontainer.GetChildCount();
|
||||
if(cc == 0)
|
||||
{
|
||||
ctrl.DockingStyle(GetType(), DockableCtrl::STATE_SHOW, 0);
|
||||
return AttachAsDock(ctrl);
|
||||
}
|
||||
else
|
||||
{
|
||||
targetctrl = dockcontainer.GetChildAt(cc);
|
||||
if(targetctrl) position = targetctrl->Position();
|
||||
else return *this;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
AddtoTabWindow(ctrl.Posit(position));
|
||||
SetActiveTabWindow(NULL);
|
||||
dndpos = 0;
|
||||
RefreshTabWindowList();
|
||||
return RefreshPaneFrame();
|
||||
}
|
||||
|
||||
PaneFrame& PaneFrame::AttachAsAuto(DockableCtrl& ctrl)
|
||||
{
|
||||
bool vertical = GetType() == LEFT || GetType() == RIGHT;
|
||||
AutoHideBar& bar = GetBase().GetHideBar(GetType());
|
||||
Size sz = ctrl.GetSizeHint();
|
||||
Size newsz;
|
||||
Size hidesz;
|
||||
hidesz += GetBase().GetHideBar(GetType()).GetHeight() + 4;
|
||||
|
||||
if(vertical) {
|
||||
if (sz.cx < hidesz.cx) {
|
||||
newsz = Size(maxsize, sz.cy);
|
||||
ctrl.SetSizeHint(newsz);
|
||||
}
|
||||
} else {
|
||||
if (sz.cy < hidesz.cy) {
|
||||
newsz = Size(sz.cx, maxsize);
|
||||
ctrl.SetSizeHint(newsz);
|
||||
}
|
||||
}
|
||||
bar.Attach(ctrl);
|
||||
GetBase().RefreshWidgetLayout();
|
||||
return RefreshPaneFrame();
|
||||
}
|
||||
|
||||
PaneFrame& PaneFrame::Detach(DockableCtrl& ctrl)
|
||||
{
|
||||
if(!ctrl.IsDocked()) return *this;
|
||||
if(HasChild(ctrl) && !ctrl.IsShut())
|
||||
dockcontainer.RemoveChildDock(ctrl);
|
||||
if(!dockcontainer.HasChild())
|
||||
HideFrame();
|
||||
return RefreshPaneFrame();
|
||||
}
|
||||
|
||||
DockableCtrl* PaneFrame::GetChild(int position)
|
||||
{
|
||||
return dockcontainer.GetChildAt(position);
|
||||
}
|
||||
|
||||
int PaneFrame::GetCount()
|
||||
{
|
||||
return dockcontainer.GetChildCount();
|
||||
}
|
||||
|
||||
bool PaneFrame::HasChild(DockableCtrl& ctrl)
|
||||
{
|
||||
if(dockcontainer.HasChild())
|
||||
for(int i = 1; i <= dockcontainer.GetCount(); i++)
|
||||
if(&ctrl == dockcontainer.GetChildAt(i))
|
||||
return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
void PaneFrame::ShowFrame()
|
||||
{
|
||||
SetSize(stdsize <= 4 ? maxsize : stdsize);
|
||||
RefreshPaneFrame().Enable();
|
||||
}
|
||||
|
||||
void PaneFrame::ShowFrame(Size sz)
|
||||
{
|
||||
bool horizontal = GetType() == LEFT || GetType() == RIGHT;
|
||||
|
||||
if(!dockcontainer.HasChild())
|
||||
{
|
||||
if(horizontal)
|
||||
SetSize((sz.cx > 4 && sz.cx < maxsize) ? sz.cx : maxsize);
|
||||
else
|
||||
SetSize((sz.cy > 4 && sz.cy < maxsize) ? sz.cy : maxsize);
|
||||
}
|
||||
else SetSize(size);
|
||||
RefreshPaneFrame();
|
||||
if(!IsEnabled()) Enable();
|
||||
}
|
||||
|
||||
void PaneFrame::HideFrame()
|
||||
{
|
||||
stdsize = GetSize();
|
||||
SetSize(0);
|
||||
RefreshPaneFrame().Disable();
|
||||
}
|
||||
|
||||
void PaneFrame::LockFrame()
|
||||
{
|
||||
if(IsLocked()) return;
|
||||
}
|
||||
|
||||
void PaneFrame::UnlockFrame()
|
||||
{
|
||||
if(!IsLocked()) return;
|
||||
}
|
||||
Vector<TabWindow*>& PaneFrame::GetTabWindows()
|
||||
{
|
||||
return tabwindows;
|
||||
}
|
||||
|
||||
TabWindow* PaneFrame::AddTabWindow()
|
||||
{
|
||||
Vector<TabWindow*>& tl = GetBase().GetTabWindows();
|
||||
TabWindow* tabwindow = NULL;
|
||||
tl.Add(tabwindow = new TabWindow());
|
||||
tabwindow->SetStyle(*GetBase().GetStyle());
|
||||
tabwindow->SetBase(&GetBase());
|
||||
GetBase().RefreshTabWindowList();
|
||||
return tabwindow;
|
||||
}
|
||||
|
||||
TabWindow* PaneFrame::AddTabWindow(DockableCtrl& ctrl)
|
||||
{
|
||||
Size tabnewsize;
|
||||
Vector<TabWindow*>& tl = GetBase().GetTabWindows();
|
||||
|
||||
int position = ctrl.Position();
|
||||
if(position == 0) ++position;
|
||||
TabWindow *tabwindow = FindTabWindow(position);
|
||||
if(tabwindow) return activetabwindow = tabwindow;
|
||||
tl.Add(tabwindow = new TabWindow());
|
||||
tabwindow->SetStyle(*GetBase().GetStyle());
|
||||
tabwindow->SetBase(&GetBase()).DockingStyle(GetType(), DockableCtrl::STATE_SHOW, position);
|
||||
|
||||
if(dockcontainer.HasChild())
|
||||
{
|
||||
DockableCtrl* child = dockcontainer.GetChildAt(position);
|
||||
if(child)
|
||||
{
|
||||
child->Shut();
|
||||
tabwindow->Attach(*child);
|
||||
tabnewsize = child->GetSizeHint();
|
||||
}
|
||||
}
|
||||
if(!tabwindow->IsTabbed())
|
||||
if(tabwindow->IsDocked() && !tabwindow->IsHidden()) ShowFrame(tabnewsize);
|
||||
dockcontainer.AddChildDock(*tabwindow, (dndpos == 0 || tabwindow->Position()) ? tabwindow->Position() : dndpos);
|
||||
GetBase().RefreshTabWindowList();
|
||||
return activetabwindow = tabwindow;
|
||||
}
|
||||
|
||||
void PaneFrame::RemoveTabWindow(TabWindow* tabwindow)
|
||||
{
|
||||
//TODO: Remove.
|
||||
}
|
||||
|
||||
void PaneFrame::RemoveTabWindow(int position)
|
||||
{
|
||||
//TODO: Remove.
|
||||
}
|
||||
|
||||
void PaneFrame::RemoveTabWindows()
|
||||
{
|
||||
//TODO: Remove.
|
||||
}
|
||||
|
||||
void PaneFrame::RefreshTabWindowList()
|
||||
{
|
||||
GetBase().RefreshTabWindowList();
|
||||
SetActiveTabWindow(NULL);
|
||||
}
|
||||
|
||||
void PaneFrame::AddtoTabWindow(DockableCtrl& ctrl)
|
||||
{
|
||||
TabWindow* tabwindow = FindTabWindow(ctrl.Position());
|
||||
if(!tabwindow) tabwindow = AddTabWindow(ctrl);
|
||||
tabwindow->Attach(ctrl);
|
||||
}
|
||||
|
||||
void PaneFrame::RemovefromTabWindow(DockableCtrl& ctrl)
|
||||
{
|
||||
TabWindow* tabwindow = FindTabWindow(ctrl.Position());
|
||||
if(!tabwindow) return;
|
||||
ctrl.Shut();
|
||||
if(tabwindow && tabwindow->IsShut())
|
||||
delete tabwindow;
|
||||
}
|
||||
|
||||
void PaneFrame::RemovefromTabWindow(int position)
|
||||
{
|
||||
}
|
||||
|
||||
TabWindow* PaneFrame::FindTabWindow(int position)
|
||||
{
|
||||
if(position <= 0) return NULL;
|
||||
TabWindow * tabwindow = NULL;
|
||||
|
||||
Vector<TabWindow*>& tl = GetBase().GetTabWindows();
|
||||
|
||||
for(int i = 0; i < tl.GetCount(); i++)
|
||||
{
|
||||
tabwindow = tl.At(i);
|
||||
if(tabwindow->Position() == position &&
|
||||
tabwindow->Alignment() == GetType() &&
|
||||
tabwindow->State() != DockableCtrl::STATE_TABBED)
|
||||
return tabwindow;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
TabWindow* PaneFrame::FindTabWindow(DockableCtrl& ctrl)
|
||||
{
|
||||
return NULL;
|
||||
}
|
||||
|
||||
TabWindow* PaneFrame::GetActiveTabWindow()
|
||||
{
|
||||
return activetabwindow;
|
||||
}
|
||||
|
||||
void PaneFrame::SetActiveTabWindow(TabWindow* tabwindow)
|
||||
{
|
||||
activetabwindow = tabwindow;
|
||||
}
|
||||
|
||||
bool PaneFrame::HasTabWindow(TabWindow* tabwindow)
|
||||
{
|
||||
Vector<TabWindow*>& tl = GetBase().GetTabWindows();
|
||||
for(int i = 0; i < tl.GetCount(); i++)
|
||||
if(tabwindow == tl.At(i)) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
bool PaneFrame::HasCtrlInRange(DockableCtrl& ctrl, Point p)
|
||||
{
|
||||
if(!GetBase().IsSideAllowed(GetType())) return false;
|
||||
Ctrl* first = NULL;
|
||||
Ctrl* last = NULL;
|
||||
|
||||
if(!dockcontainer.HasChild())
|
||||
return CalculateEmptyRange(ctrl, p);
|
||||
if(!(first = dockcontainer.GetFirstChild()) || !(last = dockcontainer.GetLastChild()))
|
||||
return false;
|
||||
if((first == last) && (first != dockcontainer.GetAnimationCtrl()))
|
||||
return CalculateCtrlRange(ctrl, *first, p);
|
||||
else
|
||||
{
|
||||
Ctrl* ctrl0 = first;
|
||||
while(ctrl0)
|
||||
{
|
||||
if(ctrl0 != dockcontainer.GetAnimationCtrl())
|
||||
if(CalculateCtrlRange(ctrl, *ctrl0, p)) return true;
|
||||
ctrl0 = ctrl0->GetNext();
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool PaneFrame::CalculateCtrlRange(DockableCtrl& t, Ctrl& c, Point p)
|
||||
{
|
||||
DockWindow* ctrl = reinterpret_cast<DockWindow*>(&c);
|
||||
ASSERT(ctrl);
|
||||
Rect r = ctrl->GetCtrlRect();
|
||||
int position = ctrl->Position();
|
||||
int hrange = r.GetWidth() / 3;
|
||||
int vrange = r.GetHeight() / 3;
|
||||
|
||||
if(!DnDHasSource())
|
||||
{
|
||||
if(!GetActiveTabWindow() ||
|
||||
(GetActiveTabWindow() &&
|
||||
!GetActiveTabWindow()->IsTabAnimating()))
|
||||
{
|
||||
if(Rect(r.left + hrange, r.top + vrange, r.right - hrange, r.bottom - vrange).Contains(p))
|
||||
{
|
||||
DnDSourceinRange();
|
||||
StartTabWindowAnimation(*ctrl, position);
|
||||
t.SetDropTarget(GetType(), DockableCtrl::STATE_TABBED);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if(dockcontainer.IsVert() &&
|
||||
!GetActiveTabWindow() &&
|
||||
!dockcontainer.IsAnimating())
|
||||
{
|
||||
if(Rect(r.left, r.top, r.right, r.top + vrange).Contains(p) ||
|
||||
Rect(r.left, r.bottom - vrange, r.right, r.bottom).Contains(p))
|
||||
{
|
||||
DnDSourceinRange();
|
||||
StartPaneFrameAnimation(*ctrl, p.y > r.bottom - vrange ? ++position : position);
|
||||
t.SetDropTarget(GetType(), DockableCtrl::STATE_SHOW);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
if(dockcontainer.IsHorz() &&
|
||||
!GetActiveTabWindow() &&
|
||||
!dockcontainer.IsAnimating())
|
||||
{
|
||||
if(Rect(r.left, r.top, r.left + hrange, r.bottom).Contains(p) ||
|
||||
Rect(r.right - hrange, r.top, r.right, r.bottom).Contains(p))
|
||||
{
|
||||
DnDSourceinRange();
|
||||
StartPaneFrameAnimation(*ctrl, p.x < r.left + hrange ? position : ++position);
|
||||
t.SetDropTarget(GetType(), DockableCtrl::STATE_SHOW);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
if(DnDHasSource())
|
||||
{
|
||||
if(dockcontainer.IsHorz() && dockcontainer.IsAnimating() &&
|
||||
dockcontainer.AnimationArea().Contains(p)) return true;
|
||||
if(dockcontainer.IsVert())
|
||||
{
|
||||
r = dockcontainer.AnimationArea();
|
||||
r.bottom += 5;
|
||||
r.top -= 5;
|
||||
if(dockcontainer.IsAnimating() && r.Contains(p)) return true;
|
||||
}
|
||||
|
||||
if(GetActiveTabWindow())
|
||||
if(GetActiveTabWindow()->IsTabAnimating() &&
|
||||
GetActiveTabWindow()->HasCtrlInRange()) return true;
|
||||
DnDSourceoutofRange();
|
||||
DnDAnimate(position);
|
||||
return false;
|
||||
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool PaneFrame::CalculateEmptyRange(Ctrl& c, Point p)
|
||||
{
|
||||
DockWindow* ctrl = reinterpret_cast<DockWindow*>(&c);
|
||||
ASSERT(ctrl);
|
||||
Rect r = GetScreenRect();
|
||||
if(!DnDHasSource() && !dockcontainer.HasChild() && !dockcontainer.IsAnimating())
|
||||
{
|
||||
bool state = false;
|
||||
switch(GetType())
|
||||
{
|
||||
case LEFT:
|
||||
((p.x < r.right + 20) && (p.x > r.left) && (p.y > r.top && p.y < r.bottom)) ?
|
||||
state = true : state = false; break;
|
||||
case RIGHT:
|
||||
((p.x > r.left - 20) && (p.x < r.right) && (p.y > r.top && p.y < r.bottom)) ?
|
||||
state = true : state = false; break;
|
||||
case TOP:
|
||||
((p.y < r.bottom + 20) && (p.y > r.top) && (p.x > r.left && p.x < r.right)) ?
|
||||
state = true : state = false; break;
|
||||
case BOTTOM:
|
||||
((p.y > r.top - 20) && (p.y < r.bottom) && (p.x > r.left && p.x < r.right)) ?
|
||||
state = true : state = false; break;
|
||||
}
|
||||
if(state)
|
||||
{
|
||||
ShowFrame(ctrl->GetSizeHint());
|
||||
DnDSourceinRange();
|
||||
StartPaneFrameAnimation(reinterpret_cast<DockableCtrl&>(c), 1);
|
||||
ctrl->SetDropTarget(GetType(), DockableCtrl::STATE_SHOW);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
if(DnDHasSource())
|
||||
{
|
||||
|
||||
if(dockcontainer.IsAnimating() && dockcontainer.AnimationArea().Contains(p)) return true;
|
||||
HideFrame();
|
||||
DnDSourceoutofRange();
|
||||
StopPaneFrameAnimation();
|
||||
return false;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------------------------
|
||||
|
||||
void PaneFrame::StartPaneFrameAnimation(DockableCtrl& ctrl, int position)
|
||||
{
|
||||
if(DnDHasSource() && !dockcontainer.IsAnimating())
|
||||
{
|
||||
if(HasTabWindow(GetActiveTabWindow()))
|
||||
if(GetActiveTabWindow()->IsTabAnimating())
|
||||
GetActiveTabWindow()->StopTabAnimation();
|
||||
dockcontainer.StartAnimation(position);
|
||||
dndpos = position;
|
||||
}
|
||||
RefreshPaneFrame();
|
||||
}
|
||||
|
||||
void PaneFrame::StartTabWindowAnimation(DockableCtrl& ctrl, int position)
|
||||
{
|
||||
if(DnDHasSource() && &ctrl && (ctrl.Position() == position))
|
||||
{
|
||||
RefreshTabWindowList();
|
||||
if(!HasTabWindow(GetActiveTabWindow()))
|
||||
activetabwindow = AddTabWindow(ctrl);
|
||||
if(!GetActiveTabWindow()->IsTabAnimating())
|
||||
{
|
||||
if(dockcontainer.IsAnimating()) dockcontainer.StopAnimation();
|
||||
GetActiveTabWindow()->StartTabAnimation();
|
||||
}
|
||||
dndpos = position;
|
||||
}
|
||||
RefreshPaneFrame();
|
||||
}
|
||||
|
||||
void PaneFrame::StopPaneFrameAnimation()
|
||||
{
|
||||
if(!DnDHasSource() && dockcontainer.IsAnimating())
|
||||
dockcontainer.StopAnimation();
|
||||
RefreshPaneFrame();
|
||||
}
|
||||
|
||||
void PaneFrame::StopTabWindowAnimation()
|
||||
{
|
||||
if(!DnDHasSource() && HasTabWindow(GetActiveTabWindow()))
|
||||
if(GetActiveTabWindow()->IsTabAnimating())
|
||||
{
|
||||
GetActiveTabWindow()->StopTabAnimation();
|
||||
RefreshTabWindowList();
|
||||
}
|
||||
RefreshPaneFrame();
|
||||
}
|
||||
|
||||
|
||||
|
||||
void PaneFrame::DnDAnimate(int position)
|
||||
{
|
||||
if(!(dockcontainer.IsAnimating() && dockcontainer.GetAnimationCtrl()->GetScreenRect().Contains(GetMousePos())))
|
||||
StopPaneFrameAnimation();
|
||||
if(HasTabWindow(GetActiveTabWindow()))
|
||||
if(!(GetActiveTabWindow()->IsTabAnimating() && GetActiveTabWindow()->HasCtrlInRange()))
|
||||
StopTabWindowAnimation();
|
||||
}
|
||||
|
||||
|
||||
//----------------------------------------------------------------------------------------------
|
||||
|
||||
PaneFrame& PaneFrame::SetLayout(DockBase* basectrl, int alignment, int _maxsize)
|
||||
{
|
||||
ASSERT(basectrl);
|
||||
base = basectrl;
|
||||
MaxSize(_maxsize);
|
||||
|
||||
switch(alignment)
|
||||
{
|
||||
case LEFT:
|
||||
Left(dockcontainer.SizePos(), 0);
|
||||
break;
|
||||
case TOP:
|
||||
Top(dockcontainer.SizePos(), 0);
|
||||
break;
|
||||
case RIGHT:
|
||||
Right(dockcontainer.SizePos(), 0);
|
||||
break;
|
||||
case BOTTOM:
|
||||
Bottom(dockcontainer.SizePos(), 0);
|
||||
break;
|
||||
}
|
||||
HideFrame();
|
||||
created = true;
|
||||
return *this;
|
||||
}
|
||||
|
||||
void PaneFrame::FrameAdd(Ctrl& parent)
|
||||
{
|
||||
parent.Add(*this);
|
||||
}
|
||||
|
||||
void PaneFrame::FrameRemove()
|
||||
{
|
||||
this->Ctrl::Remove();
|
||||
}
|
||||
|
||||
void PaneFrame::FrameAddSize(Size& sz)
|
||||
{
|
||||
if(IsShown())
|
||||
if(type == LEFT || type == RIGHT)
|
||||
{
|
||||
sz.cx += size;
|
||||
maxsize = sz.cx / 3;
|
||||
}
|
||||
else
|
||||
{
|
||||
sz.cy += size;
|
||||
maxsize = sz.cy / 3;
|
||||
}
|
||||
}
|
||||
|
||||
int PaneFrame::BoundSize()
|
||||
{
|
||||
int maxsize = max(0, (type == LEFT || type == RIGHT ? parentsize.cx : parentsize.cy) - sizemin);
|
||||
return IsShown() ? max(1, minmax(size, minsize - 1, maxsize)) : 0;
|
||||
}
|
||||
|
||||
void PaneFrame::FrameLayout(Rect& r)
|
||||
{
|
||||
Rect rr = r;
|
||||
parentsize = r.GetSize();
|
||||
int sz = BoundSize();
|
||||
switch(type) {
|
||||
case LEFT:
|
||||
r.left += sz;
|
||||
rr.right = r.left;
|
||||
break;
|
||||
case RIGHT:
|
||||
r.right -= sz;
|
||||
rr.left = r.right;
|
||||
break;
|
||||
case TOP:
|
||||
r.top += sz;
|
||||
rr.bottom = r.top;
|
||||
break;
|
||||
case BOTTOM:
|
||||
r.bottom -= sz;
|
||||
rr.top = r.bottom;
|
||||
break;
|
||||
}
|
||||
SetFrameRect(rr);
|
||||
}
|
||||
|
||||
void PaneFrame::Paint(Draw& draw)
|
||||
{
|
||||
draw.DrawRect(
|
||||
Ctrl::GetSize(),
|
||||
HasCapture() ? GUI_GlobalStyle() >= GUISTYLE_XP ? Blend(SColorHighlight, SColorFace) : SColorShadow
|
||||
: SColorFace()
|
||||
);
|
||||
}
|
||||
|
||||
void PaneFrame::LeftDown(Point p, dword)
|
||||
{
|
||||
SetCapture();
|
||||
Refresh();
|
||||
ref = GetMousePos();
|
||||
size0 = BoundSize();
|
||||
}
|
||||
|
||||
void PaneFrame::MouseMove(Point p, dword keyflags)
|
||||
{
|
||||
if(!HasCapture())
|
||||
return;
|
||||
p = GetMousePos();
|
||||
switch(type) {
|
||||
case LEFT: size = size0 + p.x - ref.x; break;
|
||||
case RIGHT: size = size0 + ref.x - p.x; break;
|
||||
case TOP: size = size0 + p.y - ref.y; break;
|
||||
case BOTTOM: size = size0 + ref.y - p.y; break;
|
||||
}
|
||||
RefreshParentLayout();
|
||||
}
|
||||
|
||||
void PaneFrame::LeftUp(Point p, dword keyflags)
|
||||
{
|
||||
Refresh();
|
||||
}
|
||||
|
||||
Image PaneFrame::CursorImage(Point p, dword keyflags)
|
||||
{
|
||||
return type == LEFT || type == RIGHT ? Image::SizeHorz() : Image::SizeVert();
|
||||
}
|
||||
|
||||
PaneFrame& PaneFrame::Set(Ctrl& c, int _size, int _type)
|
||||
{
|
||||
while(GetFirstChild())
|
||||
GetFirstChild()->Remove();
|
||||
type = _type;
|
||||
size = _size;
|
||||
Add(c.SizePos());
|
||||
switch(type) {
|
||||
case LEFT: c.HSizePos(0, 4); break;
|
||||
case RIGHT: c.HSizePos(4, 0); break;
|
||||
case TOP: c.VSizePos(0, 4); break;
|
||||
case BOTTOM: c.VSizePos(4, 0); break;
|
||||
}
|
||||
RefreshParentLayout();
|
||||
return *this;
|
||||
}
|
||||
|
||||
PaneFrame::PaneFrame()
|
||||
{
|
||||
type = LEFT;
|
||||
size = size0 = 1;
|
||||
minsize = 0;
|
||||
maxsize = 0;
|
||||
stdsize = 0;
|
||||
sizemin = 0;
|
||||
dndpos = 0;
|
||||
ncount = 0;
|
||||
locked = false;
|
||||
created = false;
|
||||
activetabwindow = NULL;
|
||||
}
|
||||
|
||||
PaneFrame::~PaneFrame()
|
||||
{
|
||||
}
|
||||
161
archive/DockCtrl/PaneSplitter.cpp
Normal file
161
archive/DockCtrl/PaneSplitter.cpp
Normal file
|
|
@ -0,0 +1,161 @@
|
|||
#include "DockCtrl/DockCtrl.h"
|
||||
|
||||
|
||||
PaneSplitter::PaneSplitter()
|
||||
{
|
||||
animating = false;
|
||||
SetAnimationType(PANEANIMATION); // by default.
|
||||
x = 0;
|
||||
y = 0;
|
||||
}
|
||||
|
||||
PaneSplitter::~PaneSplitter()
|
||||
{
|
||||
animating = false;
|
||||
}
|
||||
|
||||
void PaneSplitter::AddChildDock(DockableCtrl& dock)
|
||||
{
|
||||
Splitter::Add((Ctrl &)dock.SizePos());
|
||||
ReposChilds();
|
||||
}
|
||||
|
||||
void PaneSplitter::AddChildDock(DockableCtrl& dock, int position)
|
||||
{
|
||||
int count = GetCount();
|
||||
if(!HasChild() || position > count) AddChildDock(dock);
|
||||
else AddChildBefore((Ctrl*) &dock, (Ctrl *) GetChildAt(position));
|
||||
ReposChilds();
|
||||
}
|
||||
|
||||
void PaneSplitter::RemoveChildDock(DockableCtrl& dock)
|
||||
{
|
||||
RemoveChildDock(dock.Position());
|
||||
}
|
||||
|
||||
void PaneSplitter::RemoveChildDock(int position)
|
||||
{
|
||||
DockableCtrl* ctrl = GetChildAt(position);
|
||||
if(ctrl) ctrl->Remove();
|
||||
ReposChilds();
|
||||
}
|
||||
|
||||
void PaneSplitter::RemoveChilds()
|
||||
{
|
||||
if(!HasChild()) return;
|
||||
for(int i = 1; i < GetCount(); i++)
|
||||
GetChildAt(i)->Shut();
|
||||
}
|
||||
|
||||
void PaneSplitter::ReposChilds()
|
||||
{
|
||||
if(!HasChild()) return;
|
||||
int i = 1;
|
||||
DockableCtrl* ctrl = (DockableCtrl*) GetFirstChild();
|
||||
ctrl->Posit(i);
|
||||
while(ctrl = (DockableCtrl*) ctrl->GetNext())
|
||||
ctrl->Posit(++i);
|
||||
if(IsOpen())
|
||||
Layout();
|
||||
}
|
||||
|
||||
DockableCtrl* PaneSplitter::GetChildAt(int position)
|
||||
{
|
||||
if(HasChild())
|
||||
{
|
||||
Ctrl* ctrl = GetFirstChild();
|
||||
while(ctrl)
|
||||
{
|
||||
if(ctrl != &animationctrl)
|
||||
if(((DockableCtrl*)ctrl)->Position() == position)
|
||||
return (DockableCtrl*) ctrl;
|
||||
ctrl = ctrl->GetNext();
|
||||
}
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int PaneSplitter::GetChildCount()
|
||||
{
|
||||
int childcount = GetCount();
|
||||
return IsAnimating() ? childcount - 1 : childcount;
|
||||
}
|
||||
|
||||
bool PaneSplitter::HasChild()
|
||||
{
|
||||
return GetChildCount();
|
||||
}
|
||||
|
||||
void PaneSplitter::StartAnimation(int position)
|
||||
{
|
||||
if(animationctrl.IsOpen()) return;
|
||||
if(!HasChild() || position > GetCount())
|
||||
Splitter::Add(animationctrl.SizePos());
|
||||
else
|
||||
AddChildBefore(&animationctrl.SizePos(), (Ctrl *) GetChildAt(position));
|
||||
|
||||
animating = true;
|
||||
|
||||
if(animationtype == TABANIMATION)
|
||||
{
|
||||
Ctrl* ctrl = GetChildAt(GetZoom() + 1);
|
||||
if(ctrl)
|
||||
{
|
||||
const DockCtrlChStyle::Style& s = DockCtrlChStyle::StyleDefault();
|
||||
Size sz = animationctrl.GetSize();
|
||||
ImageDraw img(sz.cx, sz.cy);
|
||||
ctrl->DrawCtrlWithParent(img, 0, 0);
|
||||
img.DrawImage(sz,s.tabhighlight);
|
||||
Image i = img;
|
||||
animationctrl.SetAnimImage(i);
|
||||
}
|
||||
}
|
||||
Animate(position);
|
||||
}
|
||||
|
||||
void PaneSplitter::StartAnimation(DockableCtrl& dock, int position)
|
||||
{
|
||||
StartAnimation(position);
|
||||
}
|
||||
|
||||
void PaneSplitter::StopAnimation()
|
||||
{
|
||||
if(!animationctrl.IsOpen()) return;
|
||||
animationctrl.Type(animationtype);
|
||||
animationctrl.Remove();
|
||||
animating = false;
|
||||
}
|
||||
|
||||
void PaneSplitter::Animate(int position)
|
||||
{
|
||||
}
|
||||
|
||||
void PaneSplitter::AnimateCallback()
|
||||
{
|
||||
}
|
||||
|
||||
void PaneSplitter::Layout()
|
||||
{
|
||||
Splitter::Layout();
|
||||
}
|
||||
|
||||
void PaneSplitter::AnimationCtrl::Paint(Draw& d)
|
||||
{
|
||||
if(ctrltype != PaneSplitter::TABANIMATION)
|
||||
d.DrawRect(GetSize(), GUI_GlobalStyle() >= GUISTYLE_XP ? Blend(SColorHighlight, SColorFace) : SColorShadow);
|
||||
else
|
||||
d.DrawImage(GetSize(), image);
|
||||
}
|
||||
|
||||
//----------------------------------------------------------------------------------------------
|
||||
|
||||
void PaneSplitter::AnimationCtrl::AnimateHorz()
|
||||
{
|
||||
if(!IsVisible()) Show();
|
||||
Ctrl::LeftPos(0, 0).Layout();
|
||||
}
|
||||
void PaneSplitter::AnimationCtrl::AnimateVert()
|
||||
{
|
||||
if(!IsVisible()) Show();
|
||||
Ctrl::TopPos(0, 0).Layout();
|
||||
}
|
||||
5
archive/DockCtrl/READMEFIRST.txt
Normal file
5
archive/DockCtrl/READMEFIRST.txt
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
********************************************************************************
|
||||
THIS PACKAGE IS DEPRECEATED.
|
||||
IT IS SUPPLIED ONLY AS AN U++ EXAMPLE
|
||||
PLEASE USE "Docking" Package (by James Thomas - aka. Mrjt) instead.
|
||||
********************************************************************************
|
||||
15
archive/DockCtrl/TODO.txt
Normal file
15
archive/DockCtrl/TODO.txt
Normal file
|
|
@ -0,0 +1,15 @@
|
|||
//==============================================================================================
|
||||
// DockCtrl: A dockable widget framework for U++
|
||||
// Author: Ismail YILMAZ
|
||||
//==============================================================================================
|
||||
|
||||
To Do:
|
||||
------------------------------------------
|
||||
- add a self-explanatory "Complex Dockable Framework" example to the package.
|
||||
- add "stdsize" variable to the PaneFrame class for better size control.
|
||||
- add widget grouping support.
|
||||
- add drag-n-drop animations.
|
||||
- write documentation.
|
||||
- fix possible major, and minor bugs.
|
||||
- cleaning up the code.
|
||||
- bla, bla...
|
||||
BIN
archive/DockCtrl/icon.ico
Normal file
BIN
archive/DockCtrl/icon.ico
Normal file
Binary file not shown.
|
After Width: | Height: | Size: 6 B |
6
archive/DockCtrl/init
Normal file
6
archive/DockCtrl/init
Normal file
|
|
@ -0,0 +1,6 @@
|
|||
#ifndef _DockCtrl_icpp_init_stub
|
||||
#define _DockCtrl_icpp_init_stub
|
||||
#include "CtrlCore/init"
|
||||
#include "CtrlLib/init"
|
||||
#include "Draw/init"
|
||||
#endif
|
||||
48
archive/DockCtrlExample/DockCtrlExample.h
Normal file
48
archive/DockCtrlExample/DockCtrlExample.h
Normal file
|
|
@ -0,0 +1,48 @@
|
|||
#ifndef _DockCtrlExample_DockCtrlExample_h
|
||||
#define _DockCtrlExample_DockCtrlExample_h
|
||||
|
||||
#include <DockCtrl/DockCtrl.h>
|
||||
#include <RichEdit/RichEdit.h>
|
||||
|
||||
using namespace Upp;
|
||||
|
||||
#define LAYOUTFILE <DockCtrlExample/DockCtrlExample.lay>
|
||||
#include <CtrlCore/lay.h>
|
||||
|
||||
// DockCtrlExample class declaration.
|
||||
// Derived from DockCtrl.
|
||||
|
||||
class DockCtrlExample : public WithDockCtrlExampleLayout<DockCtrl> {
|
||||
public:
|
||||
typedef DockCtrlExample CLASSNAME;
|
||||
DockCtrlExample();
|
||||
~DockCtrlExample();
|
||||
|
||||
DockWindow dock1, dock2, dock3, dock4, dock5, dock6; // Actual Widgets - these are the dockable "client" widgets
|
||||
WithDockLayout<DockWindow> dock7; // DockWindow with layout.
|
||||
//------------------------------------------------------------------------------------------
|
||||
RichEdit richedit; // Stuff to "wrap"
|
||||
TabCtrl tabctrl; //
|
||||
Button button1, button2, button3; //
|
||||
ArrayCtrl array1, array2; //
|
||||
MenuBar menubar, menubar1; //
|
||||
ToolBar toolbar, toolbar1; //
|
||||
StatusBar statusbar; //
|
||||
//------------------------------------------------------------------------------------------
|
||||
virtual void InitDockCtrl(); // DockCtrl initialization functions
|
||||
virtual void InitCustomLayouts(); //
|
||||
|
||||
// Other methods (not necessary; only for demo purpose...
|
||||
|
||||
void Toolbar (Bar &bar);
|
||||
void Menubar (Bar &bar);
|
||||
void WindowsMenu(Bar& bar);
|
||||
void InfoMenu (Bar& bar);
|
||||
void EditMenu (Bar& bar);
|
||||
void Click() {}
|
||||
|
||||
|
||||
};
|
||||
|
||||
#endif
|
||||
|
||||
12
archive/DockCtrlExample/DockCtrlExample.lay
Normal file
12
archive/DockCtrlExample/DockCtrlExample.lay
Normal file
|
|
@ -0,0 +1,12 @@
|
|||
LAYOUT(DockCtrlExampleLayout, 200, 100)
|
||||
END_LAYOUT
|
||||
|
||||
LAYOUT(DockLayout, 248, 200)
|
||||
ITEM(LabelBox, dv___0, SetLabel(t_("DockWindow Layout Example")).HSizePosZ(4, 4).VSizePosZ(4, 8))
|
||||
ITEM(Clock, dv___1, HSizePosZ(96, 12).VSizePosZ(28, 60))
|
||||
ITEM(Button, dv___2, SetLabel(t_("Button 1")).LeftPosZ(12, 56).BottomPosZ(13, 23))
|
||||
ITEM(Button, dv___3, SetLabel(t_("Button 2")).RightPosZ(12, 56).BottomPosZ(13, 23))
|
||||
ITEM(Option, dv___4, SetLabel(t_("Option 1")).LeftPosZ(12, 68).TopPosZ(28, 16))
|
||||
ITEM(Option, dv___5, SetLabel(t_("Option 2")).LeftPosZ(12, 68).TopPosZ(52, 16))
|
||||
END_LAYOUT
|
||||
|
||||
16
archive/DockCtrlExample/DockCtrlExample.upp
Normal file
16
archive/DockCtrlExample/DockCtrlExample.upp
Normal file
|
|
@ -0,0 +1,16 @@
|
|||
description "Example code for the DockCtrl package";
|
||||
|
||||
uses
|
||||
CtrlLib,
|
||||
DockCtrl,
|
||||
RichEdit;
|
||||
|
||||
file
|
||||
DockCtrlExample.h,
|
||||
main.cpp,
|
||||
DockCtrlExample.lay;
|
||||
|
||||
mainconfig
|
||||
"" = "GUI",
|
||||
"" = "GUI NOGTK";
|
||||
|
||||
7
archive/DockCtrlExample/init
Normal file
7
archive/DockCtrlExample/init
Normal file
|
|
@ -0,0 +1,7 @@
|
|||
#ifndef _DockCtrlExample_icpp_init_stub
|
||||
#define _DockCtrlExample_icpp_init_stub
|
||||
#include "CtrlLib/init"
|
||||
#include "DockCtrl/init"
|
||||
#include "RichEdit/init"
|
||||
#include "Web/init"
|
||||
#endif
|
||||
211
archive/DockCtrlExample/main.cpp
Normal file
211
archive/DockCtrlExample/main.cpp
Normal file
|
|
@ -0,0 +1,211 @@
|
|||
#include "DockCtrlExample.h"
|
||||
|
||||
void DockCtrlExample::InitDockCtrl()
|
||||
{
|
||||
// This is an API change (from DEV 803b.1 on).
|
||||
// IntDockCtrl() method is called by DockCtrl at the application start.
|
||||
// Dock initialization must be done here!
|
||||
|
||||
// Magic Stuff...
|
||||
// DockableCtrl derived widgets use 3 variable to determine their place:
|
||||
// -----------------------------------------------------------------------------------------
|
||||
// 1) Alignment: As usual, it can be left, top, right, bottom.
|
||||
// 2) State: It can be show, hide, autohide, tab, floating, shut.
|
||||
// 3) Position: Determines the position of the widget, for example 0 means the widget is
|
||||
// on its own (usually, at floating state, or shut). So, any "docked" widget
|
||||
// is at least in position 1. In normal docking mode (no tabbing) system
|
||||
// adds the dock automatically to the end of the list, so this variable is
|
||||
// optional for the user.
|
||||
// -----------------------------------------------------------------------------------------
|
||||
// Tabbing styles: While any type of manipulation is possible with the above variables,
|
||||
// tabbing is a little different. (From DockCtrl version DEV803b.1 on, there
|
||||
// are two ways to tab two (or more) dockable widgets):
|
||||
//
|
||||
// 1) MANUAL TABBING: As the name may suggest, in "manual" tabbing method use
|
||||
// state and position combination to "tab" dockable widgets.
|
||||
//
|
||||
// Let's assume that we have 3 widgets docked on the "top" pane. And let's
|
||||
// say that we want to add two more docks on the top pane. We have three
|
||||
// alternatives: a) We can add it in usual way, and let the framework
|
||||
// handle the positioning. b) We can determine the position to dock.
|
||||
// (e.g. if we want to add it to 2. position, position should be 2).
|
||||
// c) We can tab docks. Now, to tab a dock, all we have to do is to set the
|
||||
// two variables properly: state and position. "State" should be "tabbed".
|
||||
// "position" should be the position where we want to tab (e.g. If we want
|
||||
// to tab the first dock then position should be 1).
|
||||
//
|
||||
// This is a framework design issue; because, with this way it is easily possible
|
||||
// to tab any number of dockable widgets simultaneously. And since it can be
|
||||
// confusing sometimes, it is a DEPRECEATED way.
|
||||
//
|
||||
// 2) TABBING USING TABIFYING METHODS: From DockCtrl version DEV803b.1, Tabify()
|
||||
// method (has 1 overload) is added to the public API. This is the easy and
|
||||
// reliable way to create tabbed widgets (either normal or nested).
|
||||
// The Syntax of Tabify is as following;
|
||||
//
|
||||
// DockableCtrl& Tabify(DockableCtrl& ctrl1, DockableCtrl& ctrl2);
|
||||
// DockableCtrl& Tabify(DockableCtrl& ctrl1, DockableCtrl& ctrl2, DockableCtrl& ctrl3, DockableCtrl& ctrl4);
|
||||
//
|
||||
// As you can see, Tabify method returns DockableCtrl& reference for the created
|
||||
// tab window, so it's both easy to tab (normal OR nested) numerous widgets simultaneously
|
||||
// and the standard docking rules apply to the created tab window (see below).
|
||||
|
||||
|
||||
Dock(dock1.SetLabel("Dock 1").DockTop().StateShow().SetIcon(CtrlImg::new_doc()));
|
||||
Dock(dock2.SetLabel("Dock 2").DockBottom().StateShow().SetIcon(CtrlImg::new_doc()));
|
||||
Dock(dock4.SetLabel("Dock 4").DockRight().StateTabbed().Posit(1).SetIcon(CtrlImg::new_doc())); // Manual tabbing example
|
||||
Dock(dock5.SetLabel("Dock 5").DockRight().StateTabbed().Posit(1).SetIcon(CtrlImg::new_doc())); //
|
||||
Dock(dock6.SetLabel("Dock 6").DockLeft().StateAuto().SetIcon(CtrlImg::new_doc())); // Manual autohide (no need to set position variable).
|
||||
|
||||
|
||||
|
||||
// Tabify():
|
||||
// Here is two tabbing examples:
|
||||
// Do not use Dock() for individual widgets when tabifying.
|
||||
// Instead, pass them to the Tabify() method, and then Dock()
|
||||
// the Tabwindow returned by Tabify().
|
||||
//
|
||||
CtrlLayout(dock7);
|
||||
dock7.SetLabel("Dock 7 - With Layout").SetIcon(CtrlImg::new_doc()); // Layout-ed dock example.
|
||||
dock3.SetLabel("Dock 3").SetIcon(CtrlImg::new_doc());
|
||||
|
||||
Dock(Tabify(dock3, dock7).DockFloat()); // Floating + Tabbing example.
|
||||
|
||||
// Here is another example. This example is mainly for demostrating
|
||||
// "nested tabbing". In order it to work correctly, you shoud
|
||||
// remove "Dock()" from the widgets passed to the method. and
|
||||
// uncomment the 2 lines below.
|
||||
//
|
||||
// AllowNestedTabbing()
|
||||
// Dock(Tabify(dock6, dock7, dock4, dock5).DockFloat());
|
||||
}
|
||||
|
||||
void DockCtrlExample::InitCustomLayouts()
|
||||
{
|
||||
// This method is called by DockCtrl for predefined custom layouts/groups.
|
||||
|
||||
// Predefined Group Example
|
||||
// ------------------------
|
||||
// You need to take two simple steps to add a predefined widget group to DockCtrl based application:
|
||||
// Step 1: Add the group using WidgetGroup() method.
|
||||
// Step 2: Use "%" operator to add ctrls to group.
|
||||
|
||||
WidgetGroup("Predefined Group 1") % dock1 % dock2 % dock3 % dock4;
|
||||
WidgetGroup("Predefined Group 2") % dock5 % dock6 % dock7;
|
||||
|
||||
// Predefined Layout Example
|
||||
// -------------------------
|
||||
// NOT IMPLEMENTED YET. TO BE WRITTEN (SOON)...
|
||||
}
|
||||
|
||||
|
||||
DockCtrlExample::DockCtrlExample()
|
||||
{
|
||||
// DockCtrl is serializable. So, you can load and save it's configuration (layouts, settings, placements, etc.) easily.
|
||||
LoadFromFile(*this, ConfigFile("dockctrlexamplelayout.bin"));
|
||||
|
||||
|
||||
CtrlLayout(*this, "DockCtrl [DEV803b.2] Example - Use 'Settings' menu options to open the control panel");
|
||||
Sizeable().Zoomable().SetRect(GetRect().left, GetRect().top, 1024, 600);
|
||||
|
||||
// Usual U++ widget preperation.
|
||||
button1.SetLabel("Hello").LeftPos(10, 100).BottomPos(10, 20);
|
||||
button2.SetLabel("Brave New").HCenterPos(90).BottomPos(10, 20);
|
||||
button3.SetLabel("World").RightPos(10, 100).BottomPos(10, 20);
|
||||
|
||||
tabctrl.Add("Tab 1");
|
||||
tabctrl.Add("Tab 2");
|
||||
|
||||
array1.AddColumn("Numbers");
|
||||
array2.AddColumn("Roman Numbers");
|
||||
|
||||
for(int i = 0; i < 100; i++)
|
||||
{
|
||||
array1.Add(Format("%d", i));
|
||||
array2.Add(FormatIntRoman(i, true));
|
||||
}
|
||||
|
||||
// At the moment (this will change in near future!) any default BarCtrl should be added BEFORE DockCtrl.
|
||||
toolbar1.Set(THISBACK(Toolbar));
|
||||
menubar1.Set(THISBACK(Menubar));
|
||||
|
||||
// Here (but not necessarily) we "wrap" -or, if you prefer "dock" - the above widgets.
|
||||
dock1 << button1 << button2 << button3;
|
||||
dock2 << tabctrl.SizePos();
|
||||
dock3 << array1.SizePos();
|
||||
dock5 << array2.SizePos();
|
||||
|
||||
// Currently all DockableCtrl derived classes (e.g. DockWindow, TabWindow) can use 3 traditional "bar" ctrls of U++.
|
||||
// Namely, MenuBar, ToolBar and StatusBar. The aim of the support for seperate bar controls is to extend the DockableCtrl functionality.
|
||||
// So, you should see and use this "bar" support as a customization support for dockctrl framework itself;
|
||||
dock2.AddMenuBar(menubar);
|
||||
dock2.AddStatusBar(statusbar);
|
||||
dock3.AddToolBar(toolbar);
|
||||
|
||||
menubar.Set(THISBACK(Menubar));
|
||||
toolbar.Set(THISBACK(Toolbar));
|
||||
Add(richedit.SizePos());
|
||||
|
||||
// You can select which sides could be used to dock. See DockBase class
|
||||
// AllowLeftRight();
|
||||
}
|
||||
|
||||
DockCtrlExample::~DockCtrlExample()
|
||||
{
|
||||
StoreToFile(*this, ConfigFile("dockctrlexamplelayout.bin"));
|
||||
}
|
||||
|
||||
void DockCtrlExample::Toolbar(Bar &bar)
|
||||
{
|
||||
bar.Add(CtrlImg::open(),THISBACK(Click));
|
||||
bar.Add(CtrlImg::new_doc(),THISBACK(Click));
|
||||
bar.Add(CtrlImg::save(),THISBACK(Click));
|
||||
bar.Separator();
|
||||
bar.Add(CtrlImg::undo(),THISBACK(Click));
|
||||
bar.Add(CtrlImg::redo(),THISBACK(Click));
|
||||
bar.Add(CtrlImg::paste(),THISBACK(Click));
|
||||
bar.Add(CtrlImg::remove(),THISBACK(Click));
|
||||
bar.Separator();
|
||||
bar.Add(CtrlImg::print(),THISBACK(Click));
|
||||
}
|
||||
|
||||
void DockCtrlExample::Menubar(Bar &bar)
|
||||
{
|
||||
bar.Add("File",THISBACK(WindowsMenu));
|
||||
bar.Add("Edit",THISBACK(EditMenu));
|
||||
bar.Add("Help",THISBACK(InfoMenu));
|
||||
}
|
||||
|
||||
void DockCtrlExample::WindowsMenu(Bar& bar)
|
||||
{
|
||||
bar.Add("New", CtrlImg::new_doc(), THISBACK(Click));
|
||||
bar.Add("Open", CtrlImg::open(),THISBACK(Click));
|
||||
bar.Add("Save", CtrlImg::save(), THISBACK(Click));
|
||||
bar.Add("Save As...", CtrlImg::save_as(),THISBACK(Click));
|
||||
bar.Separator();
|
||||
bar.Add("Exit", THISBACK(Click));
|
||||
}
|
||||
|
||||
void DockCtrlExample::InfoMenu(Bar& bar)
|
||||
{
|
||||
bar.Add("Help Topics", CtrlImg::help(), THISBACK(Click));
|
||||
bar.Add("About...", THISBACK(Click));
|
||||
}
|
||||
|
||||
void DockCtrlExample::EditMenu(Bar& bar)
|
||||
{
|
||||
bar.Add("Undo", CtrlImg::undo(), THISBACK(Click));
|
||||
bar.Add("Redo", CtrlImg::redo(), THISBACK(Click));
|
||||
bar.Separator();
|
||||
bar.Add("Paste", CtrlImg::paste(), THISBACK(Click));
|
||||
bar.Add("Remove", CtrlImg::remove(), THISBACK(Click));
|
||||
}
|
||||
|
||||
|
||||
GUI_APP_MAIN
|
||||
{
|
||||
SetLanguage(::GetSystemLNG());
|
||||
// SetDefaultCharset(CHARSET_UTF8);
|
||||
DockCtrlExample().Run();
|
||||
}
|
||||
|
||||
Loading…
Add table
Add a link
Reference in a new issue