?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch '138-toggle-free-look-with-hotkey' into 'main/atys-live'
[ryzomcore.git] / nel / src / gui / group_header.cpp
blob2671c2a62143f26d49b853fb741b5d0871ce4343
1 // Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
2 // Copyright (C) 2010 Winch Gate Property Limited
3 //
4 // This source file has been modified by the following contributors:
5 // Copyright (C) 2013 Laszlo KIS-ADAM (dfighter) <dfighter1985@gmail.com>
6 // Copyright (C) 2020 Jan BOON (Kaetemi) <jan.boon@kaetemi.be>
7 //
8 // This program is free software: you can redistribute it and/or modify
9 // it under the terms of the GNU Affero General Public License as
10 // published by the Free Software Foundation, either version 3 of the
11 // License, or (at your option) any later version.
12 //
13 // This program is distributed in the hope that it will be useful,
14 // but WITHOUT ANY WARRANTY; without even the implied warranty of
15 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 // GNU Affero General Public License for more details.
17 //
18 // You should have received a copy of the GNU Affero General Public License
19 // along with this program. If not, see <http://www.gnu.org/licenses/>.
20
21
22 #include "stdpch.h"
23 #include "nel/gui/group_container.h"
24 #include "nel/gui/group_header.h"
25 #include "nel/gui/lua_ihm.h"
26 #include "nel/gui/widget_manager.h"
27
28
29 using namespace NLMISC;
30
31 #ifdef DEBUG_NEW
32 #define new DEBUG_NEW
33 #endif
34
35 namespace NLGUI
36 {
37
38 //////////////////
39 // CGroupHeader //
40 //////////////////
41
42 // *****************************************************************************************************************
43 CGroupHeader::CGroupHeader(const TCtorParam &param) : CGroupList(param), _HeaderMaxSize(32767)
44 {
45 }
46
47 // *****************************************************************************************************************
48 void CGroupHeader::enlargeColumns(sint32 margin)
49 {
50 std::vector<CGroupHeaderEntry *> entries;
51 getEntries(entries);
52 sint32 totalWidth = 0;
53 for (uint k = 0; k < entries.size(); ++k)
54 {
55 CInterfaceGroup *colEnclosing = entries[k]->getTargetColumn();
56 if (colEnclosing && !colEnclosing->getGroups().empty())
57 {
58 CInterfaceGroup *col = colEnclosing->getGroups()[0];
59 if (col)
60 {
61 // enlarge to the max to be able to measure the sub text (they may clamp themselves based
62 // on their first non-"child resizing" parent (see CViewText::updateCoords)
63 colEnclosing->setW(16384);
64 colEnclosing->invalidateCoords();
65 colEnclosing->updateCoords();
66
67 // assume that first child is resizing from its children width (either 'child_resize_w=true' or a CGroupList)
68 entries[k]->setW(std::max(entries[k]->getMinSize(), col->getW() + margin));
69 entries[k]->invalidateCoords();
70 totalWidth += entries[k]->getW();
71 }
72 }
73 }
74 // if total width bigger than allowed, reduce proportionnally
75 if (totalWidth > _HeaderMaxSize)
76 {
77 while (totalWidth > _HeaderMaxSize)
78 {
79 bool adjusted = false;
80 // stupid algo here, but ponctual ...
81 for (uint k = 0; k < entries.size() && totalWidth > _HeaderMaxSize; ++k)
82 {
83 if (entries[k]->getW() > entries[k]->getMinSize())
84 {
85 entries[k]->setW(entries[k]->getW() - 1);
86 entries[k]->invalidateCoords();
87 --totalWidth;
88 adjusted = true;
89 }
90 }
91 // if all at min size, just exit ...
92 if (!adjusted) break;
93 }
94 }
95 else
96 {
97 // search first parent that limit size, if it is larger then enlarge to fit size
98 CInterfaceGroup *limitingParent = getParent();
99 while (limitingParent && (limitingParent->getResizeFromChildW() || dynamic_cast<CGroupList *>(limitingParent)))
100 {
101 // NB nico : the dynamic_cast for CGroupList is bad!!
102 // can't avoid it for now, because, CGroupList implicitly does a "resize from child" in its update coords
103 // ...
104 limitingParent = limitingParent->getParent();
105 }
106 if (limitingParent && limitingParent->getWReal() > totalWidth)
107 {
108 while (limitingParent->getWReal() > totalWidth && totalWidth < _HeaderMaxSize)
109 {
110 // enlarge to matche parent size
111 // stupid algo here, but ponctual ...
112 for (uint k = 0; k < entries.size(); ++k)
113 {
114 entries[k]->setW(entries[k]->getW() + 1);
115 entries[k]->invalidateCoords();
116 ++totalWidth;
117 if (limitingParent->getWReal() <= totalWidth || totalWidth >= _HeaderMaxSize) break;
118 }
119 }
120 }
121 }
122 invalidateCoords();
123 }
124
125 // *****************************************************************************************************************
126 void CGroupHeader::resizeColumnsAndContainer(sint32 margin)
127 {
128 std::vector<CGroupHeaderEntry *> entries;
129 getEntries(entries);
130 sint32 totalWidth = 0;
131 for (uint k = 0; k < entries.size(); ++k)
132 {
133 CInterfaceGroup *colEnclosing = entries[k]->getTargetColumn();
134 if (colEnclosing && !colEnclosing->getGroups().empty())
135 {
136 CInterfaceGroup *col = colEnclosing->getGroups()[0];
137 if (col)
138 {
139 // enlarge to the max to be able to measure the sub text (they may clamp themselves based
140 // on their first non-"child resizing" parent (see CViewText::updateCoords)
141 colEnclosing->setW(16384);
142 colEnclosing->invalidateCoords();
143 colEnclosing->updateCoords();
144
145 // assume that first child is resizing from its children width (either 'child_resize_w=true' or a CGroupList)
146 entries[k]->setW(std::max(entries[k]->getMinSize(), col->getW() + margin));
147 entries[k]->invalidateCoords();
148 totalWidth += entries[k]->getW();
149 }
150 }
151 }
152
153 // resize W
154 if (totalWidth <= _HeaderMaxSize)
155 {
156 // search first parent that limit size, if it is larger then enlarge to fit size
157 CInterfaceGroup *limitingParent = getParent();
158 while (limitingParent && (limitingParent->getResizeFromChildW() || dynamic_cast<CGroupList *>(limitingParent)))
159 {
160 // NB nico : the dynamic_cast for CGroupList is bad!!
161 // can't avoid it for now, because, CGroupList implicitly does a "resize from child" in its update coords
162 // ...
163 limitingParent = limitingParent->getParent();
164 }
165 if (limitingParent)
166 {
167 getParentContainer()->setW(totalWidth + getParentContainer()->getWReal() - limitingParent->getWReal());
168 }
169 else
170 {
171 nlwarning("No limiting parent for width");
172 }
173 }
174
175 // resize H
176 if (!entries.empty())
177 {
178 CInterfaceGroup *colEnclosing = entries[0]->getTargetColumn();
179 if (colEnclosing && !colEnclosing->getGroups().empty())
180 {
181 CInterfaceGroup *col = colEnclosing->getGroups()[0];
182 if (col)
183 {
184 // search first parent that limit size, if it is larger then enlarge to fit size
185 CInterfaceGroup *limitingParent = colEnclosing->getParent();
186 while (limitingParent && (limitingParent->getResizeFromChildH() || dynamic_cast<CGroupList *>(limitingParent)))
187 limitingParent = limitingParent->getParent();
188 if (limitingParent)
189 {
190 getParentContainer()->setH(col->getH() + getParentContainer()->getHReal() - limitingParent->getHReal());
191 }
192 else
193 {
194 nlwarning("No limiting parent for height");
195 }
196 }
197 }
198 }
199
200
201 invalidateCoords();
202 }
203
204 // *****************************************************************************************************************
205 void CGroupHeader::getEntries(std::vector<CGroupHeaderEntry *> &dest)
206 {
207 dest.clear();
208 const std::vector<CInterfaceGroup*> &groups = getGroups();
209 for (uint k = 0; k < groups.size(); ++k)
210 {
211 CGroupHeaderEntry *entry = dynamic_cast<CGroupHeaderEntry *>(groups[k]);
212 if (entry)
213 {
214 dest.push_back(entry);
215 }
216 }
217 }
218
219 // *****************************************************************************************************************
220 int CGroupHeader::luaEnlargeColumns(CLuaState &ls)
221 {
222 const char *funcName = "enlargeColumns";
223 CLuaIHM::checkArgCount(ls, funcName, 1);
224 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
225 enlargeColumns((sint32) ls.toInteger(1));
226 return 0;
227 }
228
229 // *****************************************************************************************************************
230 int CGroupHeader::luaResizeColumnsAndContainer(CLuaState &ls)
231 {
232 const char *funcName = "resizeColumnsAndContainer";
233 CLuaIHM::checkArgCount(ls, funcName, 1);
234 CLuaIHM::checkArgType(ls, funcName, 1, LUA_TNUMBER);
235 resizeColumnsAndContainer((sint32) ls.toInteger(1));
236 return 0;
237 }
238
239 std::string CGroupHeader::getProperty( const std::string &name ) const
240 {
241 if( name == "header_max_size" )
242 {
243 return toString( _HeaderMaxSize );
244 }
245 else
246 return CGroupList::getProperty( name );
247 }
248
249 void CGroupHeader::setProperty( const std::string &name, const std::string &value )
250 {
251 if( name == "header_max_size" )
252 {
253 sint32 i;
254 if( fromString( value, i ) )
255 _HeaderMaxSize = i;
256 return;
257 }
258 else
259 return CGroupList::setProperty( name, value );
260 }
261
262
263 xmlNodePtr CGroupHeader::serialize( xmlNodePtr parentNode, const char *type ) const
264 {
265 xmlNodePtr node = CGroupList::serialize( parentNode, type );
266 if( node == NULL )
267 return NULL;
268
269 xmlSetProp( node, BAD_CAST "type", BAD_CAST "header" );
270 xmlSetProp( node, BAD_CAST "header_max_size", BAD_CAST toString( _HeaderMaxSize ).c_str() );
271
272 return node;
273 }
274
275 // *****************************************************************************************************************
276 bool CGroupHeader::parse(xmlNodePtr cur, CInterfaceGroup * parentGroup)
277 {
278 if(!CGroupList::parse(cur, parentGroup)) return false;
279 CXMLAutoPtr prop((const char*) xmlGetProp( cur, (xmlChar*)"header_max_size" ));
280 if (prop) fromString((const char*)prop, _HeaderMaxSize);
281 return true;
282 }
283
284 /////////////////////////
285 // CHeaderEntryResizer //
286 /////////////////////////
287
288 class CHeaderEntryResizer : public CCtrlBase
289 {
290 public:
291 CHeaderEntryResizer(bool rightSide, sint32 wMin) : CCtrlBase(TCtorParam()),
292 _RightSide(rightSide),
293 _Moving(false),
294 _StartX(0),
295 _OffsetX(0),
296 _WMin(wMin)
297 {}
298 void release()
299 {
300 if (CWidgetManager::getInstance()->getCapturePointerLeft() == this)
301 {
302 _Moving = false;
303 CWidgetManager::getInstance()->setCapturePointerLeft(NULL);
304 }
305 }
306 virtual uint getDeltaDepth() const { return 100; }
307 CInterfaceGroup *getTargetGroup()
308 {
309 if (_RightSide) return _Parent;
310
311 if (getParent()->getParent() == _Parent->getParentPos()) return NULL; // leftmost header
312 return dynamic_cast<CInterfaceGroup *>(getParent()->getParentPos());
313 }
314 bool handleEvent (const NLGUI::CEventDescriptor &event)
315 {
316 if (_Parent)
317 {
318 if (event.getType() == NLGUI::CEventDescriptor::system)
319 {
320 const NLGUI::CEventDescriptorSystem &eds = (const NLGUI::CEventDescriptorSystem &) event;
321 if (eds.getEventTypeExtended() == NLGUI::CEventDescriptorSystem::setfocus)
322 {
323 const NLGUI::CEventDescriptorSetFocus &edsf = (const NLGUI::CEventDescriptorSetFocus &) eds;
324 if (edsf.hasFocus() == false)
325 {
326 release();
327 return CCtrlBase::handleEvent(event);
328 }
329 }
330 }
331 if (event.getType() == NLGUI::CEventDescriptor::mouse)
332 {
333 const NLGUI::CEventDescriptorMouse &eventDesc = (const NLGUI::CEventDescriptorMouse &)event;
334 if (eventDesc.getEventTypeExtended() == NLGUI::CEventDescriptorMouse::mouseleftdown)
335 {
336 if (!this->isIn(eventDesc.getX(), eventDesc.getY())) return false;
337 _TargetGroup = getTargetGroup();
338 if (!_TargetGroup) return false;
339 CWidgetManager::getInstance()->setCapturePointerLeft(this);
340 _Moving = true;
341 _OffsetX = _TargetGroup->getW() - eventDesc.getX();
342 return true;
343 }
344 if (eventDesc.getEventTypeExtended() == NLGUI::CEventDescriptorMouse::mouseleftup)
345 {
346 release();
347 }
348 if (eventDesc.getEventTypeExtended() == NLGUI::CEventDescriptorMouse::mousemove)
349 {
350 if (_Moving && CWidgetManager::getInstance()->getCapturePointerLeft() == this)
351 {
352 if (!_TargetGroup)
353 {
354 release();
355 return false;
356 }
357 sint32 newW = eventDesc.getX() + _OffsetX;
358 // compute width of all header entries but this one
359 CGroupHeader *header = dynamic_cast<CGroupHeader *>(getParent()->getParent());
360 if (header)
361 {
362 sint32 w = 0;
363 for (uint k = 0; k < header->getNumChildren(); ++k)
364 {
365 if (header->getChild(k) != _TargetGroup)
366 {
367 w += header->getChild(k)->getW();
368 }
369 }
370 sint32 excess = w + newW - header->getHeaderMaxSize();
371 if (excess)
372 {
373 // try to diminish the size of all headers starting from the last
374 for (sint k = header->getNumChildren() - 1; k >= 0 && excess > 0; --k)
375 {
376 if (header->getChild(k) == _TargetGroup) break;
377 CGroupHeaderEntry *ghe = dynamic_cast<CGroupHeaderEntry *>(header->getChild(k));
378 sint32 wGain = std::min(excess, std::max((sint32) 0, ghe->getW() - ghe->getMinSize()));
379 if (wGain > 0)
380 {
381 ghe->setW(ghe->getW() - wGain);
382 ghe->invalidateCoords();
383 excess -= wGain;
384 }
385 }
386 }
387 newW -= std::max((sint32) 0, excess);
388 }
389 _TargetGroup->setW(std::max(_WMin, newW));
390 _TargetGroup->invalidateCoords();
391 CGroupHeaderEntry *ghe = dynamic_cast<CGroupHeaderEntry *>((CInterfaceGroup *) _TargetGroup);
392 if (ghe)
393 {
394 ghe->setW(_TargetGroup->getW());
395 ghe->invalidateCoords();
396 CAHManager::getInstance()->runActionHandler(ghe->getAHOnResize(), ghe, ghe->getAHOnResizeParams());
397 }
398 return true;
399 }
400 _Moving = false;
401 }
402 }
403 }
404 return CCtrlBase::handleEvent(event);
405 }
406 virtual void draw ()
407 {
408 // no-op
409 }
410 virtual bool getMouseOverShape(std::string &texName, uint8 &rot, NLMISC::CRGBA &col)
411 {
412
413 if (!getTargetGroup()) return false;
414 texName = "curs_resize_LR.tga";
415 rot = 0;
416 col = CRGBA::White;
417 return true;
418 }
419
420 private:
421 NLMISC::CRefPtr<CInterfaceGroup> _TargetGroup; // group for which w is modified
422 bool _RightSide; // right or left side mover ?
423 bool _Moving;
424 sint32 _StartX; // value to add to mouse to get local x pos of target group
425 sint32 _OffsetX;
426 sint32 _WMin;
427 };
428
429 // *****************************************************************************************************************
430 CGroupHeaderEntry::CGroupHeaderEntry(const TCtorParam &param) : CInterfaceGroup(param)
431 {
432 _MinSize = 4;
433 _ResizerSize = 4;
434 }
435
436 xmlNodePtr CGroupHeaderEntry::serialize( xmlNodePtr parentNode, const char *type ) const
437 {
438 xmlNodePtr node = CInterfaceGroup::serialize( parentNode, type );
439 if( node == NULL )
440 return NULL;
441
442 xmlSetProp( node, BAD_CAST "wmin", BAD_CAST toString( _MinSize ).c_str() );
443 xmlSetProp( node, BAD_CAST "resizer_size", BAD_CAST toString( _ResizerSize ).c_str() );
444 xmlSetProp( node, BAD_CAST "target", BAD_CAST toString( _TargetColumnId ).c_str() );
445 xmlSetProp( node, BAD_CAST "on_resize", BAD_CAST _AHOnResize.c_str() );
446 xmlSetProp( node, BAD_CAST "on_resize_params", BAD_CAST _AHOnResizeParams.c_str() );
447
448
449 return node;
450 }
451
452 // *****************************************************************************************************************
453 bool CGroupHeaderEntry::parse(xmlNodePtr cur, CInterfaceGroup * parentGroup)
454 {
455 if (!CInterfaceGroup::parse(cur, parentGroup)) return false;
456 // left mover
457 CXMLAutoPtr prop((const char*) xmlGetProp( cur, (xmlChar*)"wmin" ));
458 if (prop) fromString((const char*)prop, _MinSize);
459 prop = (char*) xmlGetProp( cur, (xmlChar*)"resizer_size" );
460 if (prop) fromString((const char*)prop, _ResizerSize);
461 prop = (char*) xmlGetProp(cur, (xmlChar*) "target");
462 if (prop) _TargetColumnId = (const char *) prop;
463
464 prop = (char*) xmlGetProp(cur, (xmlChar*) "on_resize");
465 if (prop) _AHOnResize = (const char *) prop;
466 prop = (char*) xmlGetProp(cur, (xmlChar*) "on_resize_params");
467 if (prop) _AHOnResizeParams = (const char *) prop;
468
469 CHeaderEntryResizer *hm = new CHeaderEntryResizer(false, _MinSize);
470 addCtrl(hm);
471 hm->setW(_ResizerSize);
472 hm->setSizeRef(2);
473 hm->setParent(this);
474 hm->setParentPosRef(Hotspot_TL);
475 hm->setPosRef(Hotspot_TL);
476 // right mover
477 hm = new CHeaderEntryResizer(true, _MinSize);
478 addCtrl(hm);
479 hm->setW(_ResizerSize);
480 hm->setSizeRef(2);
481 hm->setParent(this);
482 hm->setParentPosRef(Hotspot_TR);
483 hm->setPosRef(Hotspot_TR);
484 //
485 return true;
486 }
487
488 // *****************************************************************************************************************
489 CInterfaceGroup *CGroupHeaderEntry::getTargetColumn() const
490 {
491 return dynamic_cast<CInterfaceGroup*>(CWidgetManager::getInstance()->getElementFromId(_TargetColumnId));
492 }
493
494 // *****************************************************************************************************************
495 void CGroupHeaderEntry::updateCoords()
496 {
497 CInterfaceGroup::updateCoords();
498 CInterfaceGroup *targetColumn = getTargetColumn();
499 if (targetColumn)
500 {
501 if (targetColumn->getW() != getW())
502 {
503 targetColumn->setW(getW());
504 targetColumn->invalidateCoords();
505 }
506 }
507 }
508
509
510 NLMISC_REGISTER_OBJECT(CViewBase, CGroupHeader, std::string, "header");
511 NLMISC_REGISTER_OBJECT(CViewBase, CGroupHeaderEntry, std::string, "header_entry");
512
513 }
514