1: <?php
2: /**
3: * Triggered when the resizable is created.
4: *
5: * * event Type: Event
6: * * ui Type: Object
7: *
8: * _Note: The ui object is empty but included for consistency with other
9: * events._ */
10: class QResizable_CreateEvent extends QJqUiEvent {
11: const EventName = 'resizecreate';
12: }
13: /**
14: * This event is triggered during the resize, on the drag of the resize
15: * handler.
16: *
17: * * event Type: Event
18: *
19: * * ui Type: Object
20: *
21: * * element Type: jQuery The jQuery object representing the element to
22: * be resized
23: * * helper Type: jQuery The jQuery object representing the helper
24: * thats being resized
25: * * originalElement Type: jQuery The jQuery object representing the
26: * original element before it is wrapped
27: * * originalPosition Type: Object The position represented as { left,
28: * top } before the resizable is resized
29: * * originalSize Type: Object The size represented as { width, height
30: * } before the resizable is resized
31: * * position Type: Object The current position represented as { left,
32: * top }. The values may be changed to modify where the element will be
33: * positioned. Useful for custom resizing logic.
34: * * size Type: Object The current size represented as { width, height
35: * }. The values may be changed to modify where the element will be
36: * positioned. Useful for custom resizing logic.
37: *
38: */
39: class QResizable_ResizeEvent extends QJqUiEvent {
40: const EventName = 'resize';
41: }
42: /**
43: * This event is triggered at the start of a resize operation.
44: *
45: * * event Type: Event
46: *
47: * * ui Type: Object
48: *
49: * * element Type: jQuery The jQuery object representing the element to
50: * be resized
51: * * helper Type: jQuery The jQuery object representing the helper
52: * thats being resized
53: * * originalElement Type: jQuery The jQuery object representing the
54: * original element before it is wrapped
55: * * originalPosition Type: Object The position represented as { left,
56: * top } before the resizable is resized
57: * * originalSize Type: Object The size represented as { width, height
58: * } before the resizable is resized
59: * * position Type: Object The current position represented as { left,
60: * top }
61: * * size Type: Object The current size represented as { width, height
62: * }
63: *
64: */
65: class QResizable_StartEvent extends QJqUiEvent {
66: const EventName = 'resizestart';
67: }
68: /**
69: * This event is triggered at the end of a resize operation.
70: *
71: * * event Type: Event
72: *
73: * * ui Type: Object
74: *
75: * * element Type: jQuery The jQuery object representing the element to
76: * be resized
77: * * helper Type: jQuery The jQuery object representing the helper
78: * thats being resized
79: * * originalElement Type: jQuery The jQuery object representing the
80: * original element before it is wrapped
81: * * originalPosition Type: Object The position represented as { left,
82: * top } before the resizable is resized
83: * * originalSize Type: Object The size represented as { width, height
84: * } before the resizable is resized
85: * * position Type: Object The current position represented as { left,
86: * top }
87: * * size Type: Object The current size represented as { width, height
88: * }
89: *
90: */
91: class QResizable_StopEvent extends QJqUiEvent {
92: const EventName = 'resizestop';
93: }
94:
95: /* Custom "property" event classes for this control */
96:
97: /**
98: * Generated QResizableGen class.
99: *
100: * This is the QResizableGen class which is automatically generated
101: * by scraping the JQuery UI documentation website. As such, it includes all the options
102: * as listed by the JQuery UI website, which may or may not be appropriate for QCubed. See
103: * the QResizableBase class for any glue code to make this class more
104: * usable in QCubed.
105: *
106: * @see QResizableBase
107: * @package Controls\Base
108: * @property mixed $AlsoResize
109: * One or more elements to resize synchronously with the resizable
110: * element.
111: *
112: * @property boolean $Animate
113: * Animates to the final size after resizing.
114: *
115: * @property mixed $AnimateDuration
116: * How long to animate when using the animate option.Multiple types
117: * supported:
118: *
119: * * Number: Duration in milliseconds.
120: * * String: A named duration, such as "slow" or "fast".
121: *
122:
123: *
124: * @property string $AnimateEasing
125: * Which easing to apply when using the animate option.
126: *
127: * @property mixed $AspectRatio
128: * Whether the element should be constrained to a specific aspect
129: * ratio.Multiple types supported:
130: *
131: * * Boolean: When set to true, the element will maintain its original
132: * aspect ratio.
133: * * Number: Force the element to maintain a specific aspect ratio
134: * during resizing.
135: *
136:
137: *
138: * @property boolean $AutoHide
139: * Whether the handles should hide when the user is not hovering over the
140: * element.
141: *
142: * @property mixed $Cancel
143: * Prevents resizing from starting on specified elements.
144: *
145: * @property mixed $Containment
146: * Constrains resizing to within the bounds of the specified element or
147: * region.Multiple types supported:
148: *
149: * * Selector: The resizable element will be contained to the bounding
150: * box of the first element found by the selector. If no element is
151: * found, no containment will be set.
152: * * Element: The resizable element will be contained to the bounding
153: * box of this element.
154: * * String: Possible values: "parent" and "document".
155: *
156:
157: *
158: * @property integer $Delay
159: * Tolerance, in milliseconds, for when resizing should start. If
160: * specified, resizing will not start until after mouse is moved beyond
161: * duration. This can help prevent unintended resizing when clicking on
162: * an element.
163: *
164: * @property boolean $Disabled
165: * Disables the resizable if set to true.
166: *
167: * @property integer $Distance
168: * Tolerance, in pixels, for when resizing should start. If specified,
169: * resizing will not start until after mouse is moved beyond distance.
170: * This can help prevent unintended resizing when clicking on an element.
171: *
172: * @property boolean $Ghost
173: * If set to true, a semi-transparent helper element is shown for
174: * resizing.
175: *
176: * @property array $Grid
177: * Snaps the resizing element to a grid, every x and y pixels. Array
178: * values: [ x, y ].
179: *
180: * @property mixed $Handles
181: * Which handles can be used for resizing.Multiple types supported:
182: *
183: * * String: A comma delimited list of any of the following: n, e, s, w,
184: * ne, se, sw, nw, all. The necessary handles will be auto-generated by
185: * the plugin.
186: *
187: * * Object:
188: *
189: * The following keys are supported: { n, e, s, w, ne, se, sw, nw }. The
190: * value of any specified should be a jQuery selector matching the child
191: * element of the resizable to use as that handle. If the handle is not a
192: * child of the resizable, you can pass in the DOMElement or a valid
193: * jQuery object directly.
194: *
195: * _Note: When generating your own handles, each handle must have the
196: * ui-resizable-handle class, as well as the appropriate
197: * ui-resizable-{direction} class, .e.g., ui-resizable-s._
198: *
199:
200: *
201: * @property string $Helper
202: * A class name that will be added to a proxy element to outline the
203: * resize during the drag of the resize handle. Once the resize is
204: * complete, the original element is sized.
205: *
206: * @property integer $MaxHeight
207: * The maximum height the resizable should be allowed to resize to.
208: *
209: * @property integer $MaxWidth
210: * The maximum width the resizable should be allowed to resize to.
211: *
212: * @property integer $MinHeight
213: * The minimum height the resizable should be allowed to resize to.
214: *
215: * @property integer $MinWidth
216: * The minimum width the resizable should be allowed to resize to.
217: *
218: */
219:
220: abstract class QResizableGen extends QControl {
221: protected $strJavaScripts = __JQUERY_EFFECTS__;
222: protected $strStyleSheets = __JQUERY_CSS__;
223: /** @var mixed */
224: protected $mixAlsoResize = null;
225: /** @var boolean */
226: protected $blnAnimate = null;
227: /** @var mixed */
228: protected $mixAnimateDuration = null;
229: /** @var string */
230: protected $strAnimateEasing = null;
231: /** @var mixed */
232: protected $mixAspectRatio = null;
233: /** @var boolean */
234: protected $blnAutoHide = null;
235: /** @var mixed */
236: protected $mixCancel = null;
237: /** @var mixed */
238: protected $mixContainment = null;
239: /** @var integer */
240: protected $intDelay;
241: /** @var boolean */
242: protected $blnDisabled = null;
243: /** @var integer */
244: protected $intDistance = null;
245: /** @var boolean */
246: protected $blnGhost = null;
247: /** @var array */
248: protected $arrGrid = null;
249: /** @var mixed */
250: protected $mixHandles = null;
251: /** @var string */
252: protected $strHelper = null;
253: /** @var integer */
254: protected $intMaxHeight = null;
255: /** @var integer */
256: protected $intMaxWidth = null;
257: /** @var integer */
258: protected $intMinHeight = null;
259: /** @var integer */
260: protected $intMinWidth = null;
261:
262: /**
263: * Builds the option array to be sent to the widget constructor.
264: *
265: * @return array key=>value array of options
266: */
267: protected function MakeJqOptions() {
268: $jqOptions = null;
269: if (!is_null($val = $this->AlsoResize)) {$jqOptions['alsoResize'] = $val;}
270: if (!is_null($val = $this->Animate)) {$jqOptions['animate'] = $val;}
271: if (!is_null($val = $this->AnimateDuration)) {$jqOptions['animateDuration'] = $val;}
272: if (!is_null($val = $this->AnimateEasing)) {$jqOptions['animateEasing'] = $val;}
273: if (!is_null($val = $this->AspectRatio)) {$jqOptions['aspectRatio'] = $val;}
274: if (!is_null($val = $this->AutoHide)) {$jqOptions['autoHide'] = $val;}
275: if (!is_null($val = $this->Cancel)) {$jqOptions['cancel'] = $val;}
276: if (!is_null($val = $this->Containment)) {$jqOptions['containment'] = $val;}
277: if (!is_null($val = $this->Delay)) {$jqOptions['delay'] = $val;}
278: if (!is_null($val = $this->Disabled)) {$jqOptions['disabled'] = $val;}
279: if (!is_null($val = $this->Distance)) {$jqOptions['distance'] = $val;}
280: if (!is_null($val = $this->Ghost)) {$jqOptions['ghost'] = $val;}
281: if (!is_null($val = $this->Grid)) {$jqOptions['grid'] = $val;}
282: if (!is_null($val = $this->Handles)) {$jqOptions['handles'] = $val;}
283: if (!is_null($val = $this->Helper)) {$jqOptions['helper'] = $val;}
284: if (!is_null($val = $this->MaxHeight)) {$jqOptions['maxHeight'] = $val;}
285: if (!is_null($val = $this->MaxWidth)) {$jqOptions['maxWidth'] = $val;}
286: if (!is_null($val = $this->MinHeight)) {$jqOptions['minHeight'] = $val;}
287: if (!is_null($val = $this->MinWidth)) {$jqOptions['minWidth'] = $val;}
288: return $jqOptions;
289: }
290:
291: /**
292: * Return the JavaScript function to call to associate the widget with the control.
293: *
294: * @return string
295: */
296: public function GetJqSetupFunction() {
297: return 'resizable';
298: }
299:
300: /**
301: * Returns the script that attaches the JQueryUI widget to the html object.
302: *
303: * @return string
304: */
305: public function GetEndScript() {
306: $strId = $this->GetJqControlId();
307: $jqOptions = $this->makeJqOptions();
308: $strFunc = $this->getJqSetupFunction();
309:
310: if ($strId !== $this->ControlId && QApplication::$RequestMode == QRequestMode::Ajax) {
311: // If events are not attached to the actual object being drawn, then the old events will not get
312: // deleted during redraw. We delete the old events here. This must happen before any other event processing code.
313: QApplication::ExecuteControlCommand($strId, 'off', QJsPriority::High);
314: }
315:
316: // Attach the javascript widget to the html object
317: if (empty($jqOptions)) {
318: QApplication::ExecuteControlCommand($strId, $strFunc, QJsPriority::High);
319: } else {
320: QApplication::ExecuteControlCommand($strId, $strFunc, $jqOptions, QJsPriority::High);
321: }
322:
323: return parent::GetEndScript();
324: }
325:
326: /**
327: * Removes the resizable functionality completely. This will return the
328: * element back to its pre-init state.
329: *
330: * * This method does not accept any arguments.
331: */
332: public function Destroy() {
333: QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "destroy", QJsPriority::Low);
334: }
335: /**
336: * Disables the resizable.
337: *
338: * * This method does not accept any arguments.
339: */
340: public function Disable() {
341: QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "disable", QJsPriority::Low);
342: }
343: /**
344: * Enables the resizable.
345: *
346: * * This method does not accept any arguments.
347: */
348: public function Enable() {
349: QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "enable", QJsPriority::Low);
350: }
351: /**
352: * Retrieves the resizables instance object. If the element does not have
353: * an associated instance, undefined is returned.
354: *
355: * Unlike other widget methods, instance() is safe to call on any element
356: * after the resizable plugin has loaded.
357: *
358: * * This method does not accept any arguments.
359: */
360: public function Instance() {
361: QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "instance", QJsPriority::Low);
362: }
363: /**
364: * Gets the value currently associated with the specified optionName.
365: *
366: * Note: For options that have objects as their value, you can get the
367: * value of a specific key by using dot notation. For example, "foo.bar"
368: * would get the value of the bar property on the foo option.
369: *
370: * * optionName Type: String The name of the option to get.
371: * @param $optionName
372: */
373: public function Option($optionName) {
374: QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "option", $optionName, QJsPriority::Low);
375: }
376: /**
377: * Gets an object containing key/value pairs representing the current
378: * resizable options hash.
379: *
380: * * This signature does not accept any arguments.
381: */
382: public function Option1() {
383: QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "option", QJsPriority::Low);
384: }
385: /**
386: * Sets the value of the resizable option associated with the specified
387: * optionName.
388: *
389: * Note: For options that have objects as their value, you can set the
390: * value of just one property by using dot notation for optionName. For
391: * example, "foo.bar" would update only the bar property of the foo
392: * option.
393: *
394: * * optionName Type: String The name of the option to set.
395: * * value Type: Object A value to set for the option.
396: * @param $optionName
397: * @param $value
398: */
399: public function Option2($optionName, $value) {
400: QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "option", $optionName, $value, QJsPriority::Low);
401: }
402: /**
403: * Sets one or more options for the resizable.
404: *
405: * * options Type: Object A map of option-value pairs to set.
406: * @param $options
407: */
408: public function Option3($options) {
409: QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "option", $options, QJsPriority::Low);
410: }
411:
412:
413: public function __get($strName) {
414: switch ($strName) {
415: case 'AlsoResize': return $this->mixAlsoResize;
416: case 'Animate': return $this->blnAnimate;
417: case 'AnimateDuration': return $this->mixAnimateDuration;
418: case 'AnimateEasing': return $this->strAnimateEasing;
419: case 'AspectRatio': return $this->mixAspectRatio;
420: case 'AutoHide': return $this->blnAutoHide;
421: case 'Cancel': return $this->mixCancel;
422: case 'Containment': return $this->mixContainment;
423: case 'Delay': return $this->intDelay;
424: case 'Disabled': return $this->blnDisabled;
425: case 'Distance': return $this->intDistance;
426: case 'Ghost': return $this->blnGhost;
427: case 'Grid': return $this->arrGrid;
428: case 'Handles': return $this->mixHandles;
429: case 'Helper': return $this->strHelper;
430: case 'MaxHeight': return $this->intMaxHeight;
431: case 'MaxWidth': return $this->intMaxWidth;
432: case 'MinHeight': return $this->intMinHeight;
433: case 'MinWidth': return $this->intMinWidth;
434: default:
435: try {
436: return parent::__get($strName);
437: } catch (QCallerException $objExc) {
438: $objExc->IncrementOffset();
439: throw $objExc;
440: }
441: }
442: }
443:
444: public function __set($strName, $mixValue) {
445: switch ($strName) {
446: case 'AlsoResize':
447: $this->mixAlsoResize = $mixValue;
448: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'alsoResize', $mixValue);
449: break;
450:
451: case 'Animate':
452: try {
453: $this->blnAnimate = QType::Cast($mixValue, QType::Boolean);
454: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'animate', $this->blnAnimate);
455: break;
456: } catch (QInvalidCastException $objExc) {
457: $objExc->IncrementOffset();
458: throw $objExc;
459: }
460:
461: case 'AnimateDuration':
462: $this->mixAnimateDuration = $mixValue;
463: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'animateDuration', $mixValue);
464: break;
465:
466: case 'AnimateEasing':
467: try {
468: $this->strAnimateEasing = QType::Cast($mixValue, QType::String);
469: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'animateEasing', $this->strAnimateEasing);
470: break;
471: } catch (QInvalidCastException $objExc) {
472: $objExc->IncrementOffset();
473: throw $objExc;
474: }
475:
476: case 'AspectRatio':
477: $this->mixAspectRatio = $mixValue;
478: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'aspectRatio', $mixValue);
479: break;
480:
481: case 'AutoHide':
482: try {
483: $this->blnAutoHide = QType::Cast($mixValue, QType::Boolean);
484: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'autoHide', $this->blnAutoHide);
485: break;
486: } catch (QInvalidCastException $objExc) {
487: $objExc->IncrementOffset();
488: throw $objExc;
489: }
490:
491: case 'Cancel':
492: $this->mixCancel = $mixValue;
493: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'cancel', $mixValue);
494: break;
495:
496: case 'Containment':
497: $this->mixContainment = $mixValue;
498: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'containment', $mixValue);
499: break;
500:
501: case 'Delay':
502: try {
503: $this->intDelay = QType::Cast($mixValue, QType::Integer);
504: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'delay', $this->intDelay);
505: break;
506: } catch (QInvalidCastException $objExc) {
507: $objExc->IncrementOffset();
508: throw $objExc;
509: }
510:
511: case 'Disabled':
512: try {
513: $this->blnDisabled = QType::Cast($mixValue, QType::Boolean);
514: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'disabled', $this->blnDisabled);
515: break;
516: } catch (QInvalidCastException $objExc) {
517: $objExc->IncrementOffset();
518: throw $objExc;
519: }
520:
521: case 'Distance':
522: try {
523: $this->intDistance = QType::Cast($mixValue, QType::Integer);
524: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'distance', $this->intDistance);
525: break;
526: } catch (QInvalidCastException $objExc) {
527: $objExc->IncrementOffset();
528: throw $objExc;
529: }
530:
531: case 'Ghost':
532: try {
533: $this->blnGhost = QType::Cast($mixValue, QType::Boolean);
534: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'ghost', $this->blnGhost);
535: break;
536: } catch (QInvalidCastException $objExc) {
537: $objExc->IncrementOffset();
538: throw $objExc;
539: }
540:
541: case 'Grid':
542: try {
543: $this->arrGrid = QType::Cast($mixValue, QType::ArrayType);
544: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'grid', $this->arrGrid);
545: break;
546: } catch (QInvalidCastException $objExc) {
547: $objExc->IncrementOffset();
548: throw $objExc;
549: }
550:
551: case 'Handles':
552: $this->mixHandles = $mixValue;
553: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'handles', $mixValue);
554: break;
555:
556: case 'Helper':
557: try {
558: $this->strHelper = QType::Cast($mixValue, QType::String);
559: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'helper', $this->strHelper);
560: break;
561: } catch (QInvalidCastException $objExc) {
562: $objExc->IncrementOffset();
563: throw $objExc;
564: }
565:
566: case 'MaxHeight':
567: try {
568: $this->intMaxHeight = QType::Cast($mixValue, QType::Integer);
569: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'maxHeight', $this->intMaxHeight);
570: break;
571: } catch (QInvalidCastException $objExc) {
572: $objExc->IncrementOffset();
573: throw $objExc;
574: }
575:
576: case 'MaxWidth':
577: try {
578: $this->intMaxWidth = QType::Cast($mixValue, QType::Integer);
579: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'maxWidth', $this->intMaxWidth);
580: break;
581: } catch (QInvalidCastException $objExc) {
582: $objExc->IncrementOffset();
583: throw $objExc;
584: }
585:
586: case 'MinHeight':
587: try {
588: $this->intMinHeight = QType::Cast($mixValue, QType::Integer);
589: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'minHeight', $this->intMinHeight);
590: break;
591: } catch (QInvalidCastException $objExc) {
592: $objExc->IncrementOffset();
593: throw $objExc;
594: }
595:
596: case 'MinWidth':
597: try {
598: $this->intMinWidth = QType::Cast($mixValue, QType::Integer);
599: $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'minWidth', $this->intMinWidth);
600: break;
601: } catch (QInvalidCastException $objExc) {
602: $objExc->IncrementOffset();
603: throw $objExc;
604: }
605:
606:
607: case 'Enabled':
608: $this->Disabled = !$mixValue; // Tie in standard QCubed functionality
609: parent::__set($strName, $mixValue);
610: break;
611:
612: default:
613: try {
614: parent::__set($strName, $mixValue);
615: break;
616: } catch (QCallerException $objExc) {
617: $objExc->IncrementOffset();
618: throw $objExc;
619: }
620: }
621: }
622:
623: /**
624: * If this control is attachable to a codegenerated control in a ModelConnector, this function will be
625: * used by the ModelConnector designer dialog to display a list of options for the control.
626: * @return QModelConnectorParam[]
627: **/
628: public static function GetModelConnectorParams() {
629: return array_merge(parent::GetModelConnectorParams(), array(
630: new QModelConnectorParam (get_called_class(), 'Animate', 'Animates to the final size after resizing.', QType::Boolean),
631: new QModelConnectorParam (get_called_class(), 'AnimateEasing', 'Which easing to apply when using the animate option.', QType::String),
632: new QModelConnectorParam (get_called_class(), 'AutoHide', 'Whether the handles should hide when the user is not hovering over theelement.', QType::Boolean),
633: new QModelConnectorParam (get_called_class(), 'Delay', 'Tolerance, in milliseconds, for when resizing should start. Ifspecified, resizing will not start until after mouse is moved beyondduration. This can help prevent unintended resizing when clicking onan element.', QType::Integer),
634: new QModelConnectorParam (get_called_class(), 'Disabled', 'Disables the resizable if set to true.', QType::Boolean),
635: new QModelConnectorParam (get_called_class(), 'Distance', 'Tolerance, in pixels, for when resizing should start. If specified,resizing will not start until after mouse is moved beyond distance.This can help prevent unintended resizing when clicking on an element.', QType::Integer),
636: new QModelConnectorParam (get_called_class(), 'Ghost', 'If set to true, a semi-transparent helper element is shown forresizing.', QType::Boolean),
637: new QModelConnectorParam (get_called_class(), 'Grid', 'Snaps the resizing element to a grid, every x and y pixels. Arrayvalues: [ x, y ].', QType::ArrayType),
638: new QModelConnectorParam (get_called_class(), 'Helper', 'A class name that will be added to a proxy element to outline theresize during the drag of the resize handle. Once the resize iscomplete, the original element is sized.', QType::String),
639: new QModelConnectorParam (get_called_class(), 'MaxHeight', 'The maximum height the resizable should be allowed to resize to.', QType::Integer),
640: new QModelConnectorParam (get_called_class(), 'MaxWidth', 'The maximum width the resizable should be allowed to resize to.', QType::Integer),
641: new QModelConnectorParam (get_called_class(), 'MinHeight', 'The minimum height the resizable should be allowed to resize to.', QType::Integer),
642: new QModelConnectorParam (get_called_class(), 'MinWidth', 'The minimum width the resizable should be allowed to resize to.', QType::Integer),
643: ));
644: }
645: }