1: <?php   
  2:     /**
  3:      * Triggered when the draggable 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 QDraggable_CreateEvent extends QJqUiEvent {
 11:         const EventName = 'dragcreate';
 12:     }
 13:     /**
 14:      * Triggered while the mouse is moved during the dragging, immediately
 15:      * before the current move happens.
 16:      * 
 17:      *  * event Type: Event 
 18:      * 
 19:      *  * ui Type: Object 
 20:      * 
 21:      *  * helper Type: jQuery The jQuery object representing the helper thats
 22:      * being dragged.
 23:      *  * position Type: Object Current CSS position of the helper as { top,
 24:      * left } object. The values may be changed to modify where the element
 25:      * will be positioned. This is useful for custom containment, snapping,
 26:      * etc.
 27:      *  * offset Type: Object Current offset position of the helper as {
 28:      * top, left } object.
 29:      * 
 30:      */
 31:     class QDraggable_DragEvent extends QJqUiEvent {
 32:         const EventName = 'drag';
 33:     }
 34:     /**
 35:      * Triggered when dragging starts.
 36:      * 
 37:      *  * event Type: Event 
 38:      * 
 39:      *  * ui Type: Object 
 40:      * 
 41:      *  * helper Type: jQuery The jQuery object representing the helper thats
 42:      * being dragged.
 43:      *  * position Type: Object Current CSS position of the helper as { top,
 44:      * left } object.
 45:      *  * offset Type: Object Current offset position of the helper as {
 46:      * top, left } object.
 47:      * 
 48:      */
 49:     class QDraggable_StartEvent extends QJqUiEvent {
 50:         const EventName = 'dragstart';
 51:     }
 52:     /**
 53:      * Triggered when dragging stops.
 54:      * 
 55:      *  * event Type: Event 
 56:      * 
 57:      *  * ui Type: Object 
 58:      * 
 59:      *  * helper Type: jQuery The jQuery object representing the helper thats
 60:      * being dragged.
 61:      *  * position Type: Object Current CSS position of the helper as { top,
 62:      * left } object.
 63:      *  * offset Type: Object Current offset position of the helper as {
 64:      * top, left } object.
 65:      * 
 66:      */
 67:     class QDraggable_StopEvent extends QJqUiEvent {
 68:         const EventName = 'dragstop';
 69:     }
 70: 
 71:     /* Custom "property" event classes for this control */
 72: 
 73:     /**
 74:      * Generated QDraggableGen class.
 75:      * 
 76:      * This is the QDraggableGen class which is automatically generated
 77:      * by scraping the JQuery UI documentation website. As such, it includes all the options
 78:      * as listed by the JQuery UI website, which may or may not be appropriate for QCubed. See
 79:      * the QDraggableBase class for any glue code to make this class more
 80:      * usable in QCubed.
 81:      * 
 82:      * @see QDraggableBase
 83:      * @package Controls\Base
 84:      * @property boolean $AddClasses
 85:      * If set to false, will prevent the ui-draggable class from being added.
 86:      * This may be desired as a performance optimization when calling
 87:      * .draggable() on hundreds of elements.
 88:      *
 89:      * @property mixed $AppendTo
 90:      * Which element the draggable helper should be appended to while
 91:      * dragging. Note: The appendTo option only works when the helper option
 92:      * is set to not use the original element.Multiple types supported:
 93:      * 
 94:      *  * jQuery: A jQuery object containing the element to append the helper
 95:      * to.
 96:      *  * Element: The element to append the helper to.
 97:      *  * Selector: A selector specifying which element to append the helper
 98:      * to.
 99:      *  * String: The string "parent" will cause the helper to be a sibling
100:      * of the draggable.
101:      * 
102: 
103:      *
104:      * @property string $Axis
105:      * Constrains dragging to either the horizontal (x) or vertical (y) axis.
106:      * Possible values: "x", "y".
107:      *
108:      * @property mixed $Cancel
109:      * Prevents dragging from starting on specified elements.
110:      *
111:      * @property mixed $ConnectToSortable
112:      * Allows the draggable to be dropped onto the specified sortables. If
113:      * this option is used, a draggable can be dropped onto a sortable list
114:      * and then becomes part of it. Note: The helper option must be set to
115:      * "clone" in order to work flawlessly. Requires the jQuery UI Sortable
116:      * plugin to be included.
117:      *
118:      * @property mixed $Containment
119:      * Constrains dragging to within the bounds of the specified element or
120:      * region.Multiple types supported:
121:      * 
122:      *  * Selector: The draggable element will be contained to the bounding
123:      * box of the first element found by the selector. If no element is
124:      * found, no containment will be set.
125:      *  * Element: The draggable element will be contained to the bounding
126:      * box of this element.
127:      *  * String: Possible values: "parent", "document", "window".
128:      *  * Array: An array defining a bounding box in the form [ x1, y1, x2,
129:      * y2 ].
130:      * 
131: 
132:      *
133:      * @property string $Cursor
134:      * The CSS cursor during the drag operation.
135:      *
136:      * @property mixed $CursorAt
137:      * Sets the offset of the dragging helper relative to the mouse cursor.
138:      * Coordinates can be given as a hash using a combination of one or two
139:      * keys: { top, left, right, bottom }.
140:      *
141:      * @property integer $Delay
142:      * Time in milliseconds after mousedown until dragging should start. This
143:      * option can be used to prevent unwanted drags when clicking on an
144:      * element.
145:      *
146:      * @property boolean $Disabled
147:      * Disables the draggable if set to true.
148:      *
149:      * @property integer $Distance
150:      * Distance in pixels after mousedown the mouse must move before dragging
151:      * should start. This option can be used to prevent unwanted drags when
152:      * clicking on an element.
153:      *
154:      * @property array $Grid
155:      * Snaps the dragging helper to a grid, every x and y pixels. The array
156:      * must be of the form [ x, y ].
157:      *
158:      * @property mixed $Handle
159:      * If specified, restricts dragging from starting unless the mousedown
160:      * occurs on the specified element(s). Only elements that descend from
161:      * the draggable element are permitted.
162:      *
163:      * @property mixed $Helper
164:      * Allows for a helper element to be used for dragging display.Multiple
165:      * types supported:
166:      * 
167:      *  * String: If set to "clone", then the element will be cloned and the
168:      * clone will be dragged.
169:      *  * Function: A function that will return a DOMElement to use while
170:      * dragging.
171:      * 
172: 
173:      *
174:      * @property mixed $IframeFix
175:      * Prevent iframes from capturing the mousemove events during a drag.
176:      * Useful in combination with the cursorAt option, or in any case where
177:      * the mouse cursor may not be over the helper.Multiple types supported:
178:      * 
179:      *  * Boolean: When set to true, transparent overlays will be placed over
180:      * all iframes on the page.
181:      *  * Selector: Any iframes matching the selector will be covered by
182:      * transparent overlays.
183:      * 
184: 
185:      *
186:      * @property integer $Opacity
187:      * Opacity for the helper while being dragged.
188:      *
189:      * @property boolean $RefreshPositions
190:      * If set to true, all droppable positions are calculated on every
191:      * mousemove. _Caution: This solves issues on highly dynamic pages, but
192:      * dramatically decreases performance._
193:      *
194:      * @property mixed $Revert
195:      * Whether the element should revert to its start position when dragging
196:      * stops.Multiple types supported:
197:      * 
198:      *  * Boolean: If set to true the element will always revert.
199:      *  * String: If set to "invalid", revert will only occur if the
200:      * draggable has not been dropped on a droppable. For "valid", its the
201:      * other way around.
202:      *  * Function: A function to determine whether the element should
203:      * revert to its start position. The function must return true to revert
204:      * the element.
205:      * 
206: 
207:      *
208:      * @property integer $RevertDuration
209:      * The duration of the revert animation, in milliseconds. Ignored if the
210:      * revert option is false.
211:      *
212:      * @property string $Scope
213:      * Used to group sets of draggable and droppable items, in addition to
214:      * droppables accept option. A draggable with the same scope value as a
215:      * droppable will be accepted by the droppable.
216:      *
217:      * @property boolean $Scroll
218:      * If set to true, container auto-scrolls while dragging.
219:      *
220:      * @property integer $ScrollSensitivity
221:      * Distance in pixels from the edge of the viewport after which the
222:      * viewport should scroll. Distance is relative to pointer, not the
223:      * draggable. Ignored if the scroll option is false.
224:      *
225:      * @property integer $ScrollSpeed
226:      * The speed at which the window should scroll once the mouse pointer
227:      * gets within the scrollSensitivity distance. Ignored if the scroll
228:      * option is false.
229:      *
230:      * @property mixed $Snap
231:      * Whether the element should snap to other elements.Multiple types
232:      * supported:
233:      * 
234:      *  * Boolean: When set to true, the element will snap to all other
235:      * draggable elements.
236:      *  * Selector: A selector specifying which elements to snap to.
237:      * 
238: 
239:      *
240:      * @property string $SnapMode
241:      * Determines which edges of snap elements the draggable will snap to.
242:      * Ignored if the snap option is false. Possible values: "inner",
243:      * "outer", "both".
244:      *
245:      * @property integer $SnapTolerance
246:      * The distance in pixels from the snap element edges at which snapping
247:      * should occur. Ignored if the snap option is false.
248:      *
249:      * @property mixed $Stack
250:      * Controls the z-index of the set of elements that match the selector,
251:      * always brings the currently dragged item to the front. Very useful in
252:      * things like window managers.
253:      *
254:      * @property integer $ZIndex
255:      * Z-index for the helper while being dragged.
256:      *
257:      */
258: 
259:     abstract class QDraggableGen extends QControl   {
260:         protected $strJavaScripts = __JQUERY_EFFECTS__;
261:         protected $strStyleSheets = __JQUERY_CSS__;
262:         /** @var boolean */
263:         protected $blnAddClasses = null;
264:         /** @var mixed */
265:         protected $mixAppendTo = null;
266:         /** @var string */
267:         protected $strAxis = null;
268:         /** @var mixed */
269:         protected $mixCancel = null;
270:         /** @var mixed */
271:         protected $mixConnectToSortable = null;
272:         /** @var mixed */
273:         protected $mixContainment = null;
274:         /** @var string */
275:         protected $strCursor = null;
276:         /** @var mixed */
277:         protected $mixCursorAt = null;
278:         /** @var integer */
279:         protected $intDelay;
280:         /** @var boolean */
281:         protected $blnDisabled = null;
282:         /** @var integer */
283:         protected $intDistance = null;
284:         /** @var array */
285:         protected $arrGrid = null;
286:         /** @var mixed */
287:         protected $mixHandle = null;
288:         /** @var mixed */
289:         protected $mixHelper = null;
290:         /** @var mixed */
291:         protected $mixIframeFix = null;
292:         /** @var integer */
293:         protected $intOpacity = null;
294:         /** @var boolean */
295:         protected $blnRefreshPositions = null;
296:         /** @var mixed */
297:         protected $mixRevert = null;
298:         /** @var integer */
299:         protected $intRevertDuration = null;
300:         /** @var string */
301:         protected $strScope = null;
302:         /** @var boolean */
303:         protected $blnScroll = null;
304:         /** @var integer */
305:         protected $intScrollSensitivity = null;
306:         /** @var integer */
307:         protected $intScrollSpeed = null;
308:         /** @var mixed */
309:         protected $mixSnap = null;
310:         /** @var string */
311:         protected $strSnapMode = null;
312:         /** @var integer */
313:         protected $intSnapTolerance = null;
314:         /** @var mixed */
315:         protected $mixStack = null;
316:         /** @var integer */
317:         protected $intZIndex = null;
318: 
319:         /**
320:          * Builds the option array to be sent to the widget constructor.
321:          *
322:          * @return array key=>value array of options
323:          */
324:         protected function MakeJqOptions() {
325:             $jqOptions = null;
326:             if (!is_null($val = $this->AddClasses)) {$jqOptions['addClasses'] = $val;}
327:             if (!is_null($val = $this->AppendTo)) {$jqOptions['appendTo'] = $val;}
328:             if (!is_null($val = $this->Axis)) {$jqOptions['axis'] = $val;}
329:             if (!is_null($val = $this->Cancel)) {$jqOptions['cancel'] = $val;}
330:             if (!is_null($val = $this->ConnectToSortable)) {$jqOptions['connectToSortable'] = $val;}
331:             if (!is_null($val = $this->Containment)) {$jqOptions['containment'] = $val;}
332:             if (!is_null($val = $this->Cursor)) {$jqOptions['cursor'] = $val;}
333:             if (!is_null($val = $this->CursorAt)) {$jqOptions['cursorAt'] = $val;}
334:             if (!is_null($val = $this->Delay)) {$jqOptions['delay'] = $val;}
335:             if (!is_null($val = $this->Disabled)) {$jqOptions['disabled'] = $val;}
336:             if (!is_null($val = $this->Distance)) {$jqOptions['distance'] = $val;}
337:             if (!is_null($val = $this->Grid)) {$jqOptions['grid'] = $val;}
338:             if (!is_null($val = $this->Handle)) {$jqOptions['handle'] = $val;}
339:             if (!is_null($val = $this->Helper)) {$jqOptions['helper'] = $val;}
340:             if (!is_null($val = $this->IframeFix)) {$jqOptions['iframeFix'] = $val;}
341:             if (!is_null($val = $this->Opacity)) {$jqOptions['opacity'] = $val;}
342:             if (!is_null($val = $this->RefreshPositions)) {$jqOptions['refreshPositions'] = $val;}
343:             if (!is_null($val = $this->Revert)) {$jqOptions['revert'] = $val;}
344:             if (!is_null($val = $this->RevertDuration)) {$jqOptions['revertDuration'] = $val;}
345:             if (!is_null($val = $this->Scope)) {$jqOptions['scope'] = $val;}
346:             if (!is_null($val = $this->Scroll)) {$jqOptions['scroll'] = $val;}
347:             if (!is_null($val = $this->ScrollSensitivity)) {$jqOptions['scrollSensitivity'] = $val;}
348:             if (!is_null($val = $this->ScrollSpeed)) {$jqOptions['scrollSpeed'] = $val;}
349:             if (!is_null($val = $this->Snap)) {$jqOptions['snap'] = $val;}
350:             if (!is_null($val = $this->SnapMode)) {$jqOptions['snapMode'] = $val;}
351:             if (!is_null($val = $this->SnapTolerance)) {$jqOptions['snapTolerance'] = $val;}
352:             if (!is_null($val = $this->Stack)) {$jqOptions['stack'] = $val;}
353:             if (!is_null($val = $this->ZIndex)) {$jqOptions['zIndex'] = $val;}
354:             return $jqOptions;
355:         }
356: 
357:         /**
358:          * Return the JavaScript function to call to associate the widget with the control.
359:          *
360:          * @return string
361:          */
362:         public function GetJqSetupFunction() {
363:             return 'draggable';
364:         }
365: 
366:         /**
367:          * Returns the script that attaches the JQueryUI widget to the html object.
368:          *
369:          * @return string
370:          */
371:         public function GetEndScript() {
372:             $strId = $this->GetJqControlId();
373:             $jqOptions = $this->makeJqOptions();
374:             $strFunc = $this->getJqSetupFunction();
375: 
376:             if ($strId !== $this->ControlId && QApplication::$RequestMode == QRequestMode::Ajax) {
377:                 // If events are not attached to the actual object being drawn, then the old events will not get
378:                 // deleted during redraw. We delete the old events here. This must happen before any other event processing code.
379:                 QApplication::ExecuteControlCommand($strId, 'off', QJsPriority::High);
380:             }
381: 
382:             // Attach the javascript widget to the html object
383:             if (empty($jqOptions)) {
384:                 QApplication::ExecuteControlCommand($strId, $strFunc, QJsPriority::High);
385:             } else {
386:                 QApplication::ExecuteControlCommand($strId, $strFunc, $jqOptions, QJsPriority::High);
387:             }
388: 
389:             return parent::GetEndScript();
390:         }
391: 
392:         /**
393:          * Removes the draggable functionality completely. This will return the
394:          * element back to its pre-init state.
395:          * 
396:          *  * This method does not accept any arguments.
397:          */
398:         public function Destroy() {
399:             QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "destroy", QJsPriority::Low);
400:         }
401:         /**
402:          * Disables the draggable.
403:          * 
404:          *  * This method does not accept any arguments.
405:          */
406:         public function Disable() {
407:             QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "disable", QJsPriority::Low);
408:         }
409:         /**
410:          * Enables the draggable.
411:          * 
412:          *  * This method does not accept any arguments.
413:          */
414:         public function Enable() {
415:             QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "enable", QJsPriority::Low);
416:         }
417:         /**
418:          * Retrieves the draggables instance object. If the element does not have
419:          * an associated instance, undefined is returned. 
420:          * 
421:          * Unlike other widget methods, instance() is safe to call on any element
422:          * after the draggable plugin has loaded.
423:          * 
424:          *  * This method does not accept any arguments.
425:          */
426:         public function Instance() {
427:             QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "instance", QJsPriority::Low);
428:         }
429:         /**
430:          * Gets the value currently associated with the specified optionName. 
431:          * 
432:          * Note: For options that have objects as their value, you can get the
433:          * value of a specific key by using dot notation. For example, "foo.bar"
434:          * would get the value of the bar property on the foo option.
435:          * 
436:          *  * optionName Type: String The name of the option to get.
437:          * @param $optionName
438:          */
439:         public function Option($optionName) {
440:             QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "option", $optionName, QJsPriority::Low);
441:         }
442:         /**
443:          * Gets an object containing key/value pairs representing the current
444:          * draggable options hash.
445:          * 
446:          *  * This signature does not accept any arguments.
447:          */
448:         public function Option1() {
449:             QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "option", QJsPriority::Low);
450:         }
451:         /**
452:          * Sets the value of the draggable option associated with the specified
453:          * optionName. 
454:          * 
455:          * Note: For options that have objects as their value, you can set the
456:          * value of just one property by using dot notation for optionName. For
457:          * example, "foo.bar" would update only the bar property of the foo
458:          * option.
459:          * 
460:          *  * optionName Type: String The name of the option to set.
461:          *  * value Type: Object A value to set for the option.
462:          * @param $optionName
463:          * @param $value
464:          */
465:         public function Option2($optionName, $value) {
466:             QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "option", $optionName, $value, QJsPriority::Low);
467:         }
468:         /**
469:          * Sets one or more options for the draggable.
470:          * 
471:          *  * options Type: Object A map of option-value pairs to set.
472:          * @param $options
473:          */
474:         public function Option3($options) {
475:             QApplication::ExecuteControlCommand($this->getJqControlId(), $this->getJqSetupFunction(), "option", $options, QJsPriority::Low);
476:         }
477: 
478: 
479:         public function __get($strName) {
480:             switch ($strName) {
481:                 case 'AddClasses': return $this->blnAddClasses;
482:                 case 'AppendTo': return $this->mixAppendTo;
483:                 case 'Axis': return $this->strAxis;
484:                 case 'Cancel': return $this->mixCancel;
485:                 case 'ConnectToSortable': return $this->mixConnectToSortable;
486:                 case 'Containment': return $this->mixContainment;
487:                 case 'Cursor': return $this->strCursor;
488:                 case 'CursorAt': return $this->mixCursorAt;
489:                 case 'Delay': return $this->intDelay;
490:                 case 'Disabled': return $this->blnDisabled;
491:                 case 'Distance': return $this->intDistance;
492:                 case 'Grid': return $this->arrGrid;
493:                 case 'Handle': return $this->mixHandle;
494:                 case 'Helper': return $this->mixHelper;
495:                 case 'IframeFix': return $this->mixIframeFix;
496:                 case 'Opacity': return $this->intOpacity;
497:                 case 'RefreshPositions': return $this->blnRefreshPositions;
498:                 case 'Revert': return $this->mixRevert;
499:                 case 'RevertDuration': return $this->intRevertDuration;
500:                 case 'Scope': return $this->strScope;
501:                 case 'Scroll': return $this->blnScroll;
502:                 case 'ScrollSensitivity': return $this->intScrollSensitivity;
503:                 case 'ScrollSpeed': return $this->intScrollSpeed;
504:                 case 'Snap': return $this->mixSnap;
505:                 case 'SnapMode': return $this->strSnapMode;
506:                 case 'SnapTolerance': return $this->intSnapTolerance;
507:                 case 'Stack': return $this->mixStack;
508:                 case 'ZIndex': return $this->intZIndex;
509:                 default: 
510:                     try { 
511:                         return parent::__get($strName); 
512:                     } catch (QCallerException $objExc) { 
513:                         $objExc->IncrementOffset(); 
514:                         throw $objExc; 
515:                     }
516:             }
517:         }
518: 
519:         public function __set($strName, $mixValue) {
520:             switch ($strName) {
521:                 case 'AddClasses':
522:                     try {
523:                         $this->blnAddClasses = QType::Cast($mixValue, QType::Boolean);
524:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'addClasses', $this->blnAddClasses);
525:                         break;
526:                     } catch (QInvalidCastException $objExc) {
527:                         $objExc->IncrementOffset();
528:                         throw $objExc;
529:                     }
530: 
531:                 case 'AppendTo':
532:                     $this->mixAppendTo = $mixValue;
533:                     $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'appendTo', $mixValue);
534:                     break;
535: 
536:                 case 'Axis':
537:                     try {
538:                         $this->strAxis = QType::Cast($mixValue, QType::String);
539:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'axis', $this->strAxis);
540:                         break;
541:                     } catch (QInvalidCastException $objExc) {
542:                         $objExc->IncrementOffset();
543:                         throw $objExc;
544:                     }
545: 
546:                 case 'Cancel':
547:                     $this->mixCancel = $mixValue;
548:                     $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'cancel', $mixValue);
549:                     break;
550: 
551:                 case 'ConnectToSortable':
552:                     $this->mixConnectToSortable = $mixValue;
553:                     $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'connectToSortable', $mixValue);
554:                     break;
555: 
556:                 case 'Containment':
557:                     $this->mixContainment = $mixValue;
558:                     $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'containment', $mixValue);
559:                     break;
560: 
561:                 case 'Cursor':
562:                     try {
563:                         $this->strCursor = QType::Cast($mixValue, QType::String);
564:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'cursor', $this->strCursor);
565:                         break;
566:                     } catch (QInvalidCastException $objExc) {
567:                         $objExc->IncrementOffset();
568:                         throw $objExc;
569:                     }
570: 
571:                 case 'CursorAt':
572:                     $this->mixCursorAt = $mixValue;
573:                     $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'cursorAt', $mixValue);
574:                     break;
575: 
576:                 case 'Delay':
577:                     try {
578:                         $this->intDelay = QType::Cast($mixValue, QType::Integer);
579:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'delay', $this->intDelay);
580:                         break;
581:                     } catch (QInvalidCastException $objExc) {
582:                         $objExc->IncrementOffset();
583:                         throw $objExc;
584:                     }
585: 
586:                 case 'Disabled':
587:                     try {
588:                         $this->blnDisabled = QType::Cast($mixValue, QType::Boolean);
589:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'disabled', $this->blnDisabled);
590:                         break;
591:                     } catch (QInvalidCastException $objExc) {
592:                         $objExc->IncrementOffset();
593:                         throw $objExc;
594:                     }
595: 
596:                 case 'Distance':
597:                     try {
598:                         $this->intDistance = QType::Cast($mixValue, QType::Integer);
599:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'distance', $this->intDistance);
600:                         break;
601:                     } catch (QInvalidCastException $objExc) {
602:                         $objExc->IncrementOffset();
603:                         throw $objExc;
604:                     }
605: 
606:                 case 'Grid':
607:                     try {
608:                         $this->arrGrid = QType::Cast($mixValue, QType::ArrayType);
609:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'grid', $this->arrGrid);
610:                         break;
611:                     } catch (QInvalidCastException $objExc) {
612:                         $objExc->IncrementOffset();
613:                         throw $objExc;
614:                     }
615: 
616:                 case 'Handle':
617:                     $this->mixHandle = $mixValue;
618:                     $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'handle', $mixValue);
619:                     break;
620: 
621:                 case 'Helper':
622:                     $this->mixHelper = $mixValue;
623:                     $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'helper', $mixValue);
624:                     break;
625: 
626:                 case 'IframeFix':
627:                     $this->mixIframeFix = $mixValue;
628:                     $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'iframeFix', $mixValue);
629:                     break;
630: 
631:                 case 'Opacity':
632:                     try {
633:                         $this->intOpacity = QType::Cast($mixValue, QType::Integer);
634:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'opacity', $this->intOpacity);
635:                         break;
636:                     } catch (QInvalidCastException $objExc) {
637:                         $objExc->IncrementOffset();
638:                         throw $objExc;
639:                     }
640: 
641:                 case 'RefreshPositions':
642:                     try {
643:                         $this->blnRefreshPositions = QType::Cast($mixValue, QType::Boolean);
644:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'refreshPositions', $this->blnRefreshPositions);
645:                         break;
646:                     } catch (QInvalidCastException $objExc) {
647:                         $objExc->IncrementOffset();
648:                         throw $objExc;
649:                     }
650: 
651:                 case 'Revert':
652:                     $this->mixRevert = $mixValue;
653:                     $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'revert', $mixValue);
654:                     break;
655: 
656:                 case 'RevertDuration':
657:                     try {
658:                         $this->intRevertDuration = QType::Cast($mixValue, QType::Integer);
659:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'revertDuration', $this->intRevertDuration);
660:                         break;
661:                     } catch (QInvalidCastException $objExc) {
662:                         $objExc->IncrementOffset();
663:                         throw $objExc;
664:                     }
665: 
666:                 case 'Scope':
667:                     try {
668:                         $this->strScope = QType::Cast($mixValue, QType::String);
669:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'scope', $this->strScope);
670:                         break;
671:                     } catch (QInvalidCastException $objExc) {
672:                         $objExc->IncrementOffset();
673:                         throw $objExc;
674:                     }
675: 
676:                 case 'Scroll':
677:                     try {
678:                         $this->blnScroll = QType::Cast($mixValue, QType::Boolean);
679:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'scroll', $this->blnScroll);
680:                         break;
681:                     } catch (QInvalidCastException $objExc) {
682:                         $objExc->IncrementOffset();
683:                         throw $objExc;
684:                     }
685: 
686:                 case 'ScrollSensitivity':
687:                     try {
688:                         $this->intScrollSensitivity = QType::Cast($mixValue, QType::Integer);
689:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'scrollSensitivity', $this->intScrollSensitivity);
690:                         break;
691:                     } catch (QInvalidCastException $objExc) {
692:                         $objExc->IncrementOffset();
693:                         throw $objExc;
694:                     }
695: 
696:                 case 'ScrollSpeed':
697:                     try {
698:                         $this->intScrollSpeed = QType::Cast($mixValue, QType::Integer);
699:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'scrollSpeed', $this->intScrollSpeed);
700:                         break;
701:                     } catch (QInvalidCastException $objExc) {
702:                         $objExc->IncrementOffset();
703:                         throw $objExc;
704:                     }
705: 
706:                 case 'Snap':
707:                     $this->mixSnap = $mixValue;
708:                     $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'snap', $mixValue);
709:                     break;
710: 
711:                 case 'SnapMode':
712:                     try {
713:                         $this->strSnapMode = QType::Cast($mixValue, QType::String);
714:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'snapMode', $this->strSnapMode);
715:                         break;
716:                     } catch (QInvalidCastException $objExc) {
717:                         $objExc->IncrementOffset();
718:                         throw $objExc;
719:                     }
720: 
721:                 case 'SnapTolerance':
722:                     try {
723:                         $this->intSnapTolerance = QType::Cast($mixValue, QType::Integer);
724:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'snapTolerance', $this->intSnapTolerance);
725:                         break;
726:                     } catch (QInvalidCastException $objExc) {
727:                         $objExc->IncrementOffset();
728:                         throw $objExc;
729:                     }
730: 
731:                 case 'Stack':
732:                     $this->mixStack = $mixValue;
733:                     $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'stack', $mixValue);
734:                     break;
735: 
736:                 case 'ZIndex':
737:                     try {
738:                         $this->intZIndex = QType::Cast($mixValue, QType::Integer);
739:                         $this->AddAttributeScript($this->getJqSetupFunction(), 'option', 'zIndex', $this->intZIndex);
740:                         break;
741:                     } catch (QInvalidCastException $objExc) {
742:                         $objExc->IncrementOffset();
743:                         throw $objExc;
744:                     }
745: 
746: 
747:                 case 'Enabled':
748:                     $this->Disabled = !$mixValue;   // Tie in standard QCubed functionality
749:                     parent::__set($strName, $mixValue);
750:                     break;
751:                     
752:                 default:
753:                     try {
754:                         parent::__set($strName, $mixValue);
755:                         break;
756:                     } catch (QCallerException $objExc) {
757:                         $objExc->IncrementOffset();
758:                         throw $objExc;
759:                     }
760:             }
761:         }
762: 
763:         /**
764:         * If this control is attachable to a codegenerated control in a ModelConnector, this function will be
765:         * used by the ModelConnector designer dialog to display a list of options for the control.
766:         * @return QModelConnectorParam[]
767:         **/
768:         public static function GetModelConnectorParams() {
769:             return array_merge(parent::GetModelConnectorParams(), array(
770:                 new QModelConnectorParam (get_called_class(), 'AddClasses', 'If set to false, will prevent the ui-draggable class from being added.This may be desired as a performance optimization when calling.draggable() on hundreds of elements.', QType::Boolean),
771:                 new QModelConnectorParam (get_called_class(), 'Axis', 'Constrains dragging to either the horizontal (x) or vertical (y) axis.Possible values: \"x\", \"y\".', QType::String),
772:                 new QModelConnectorParam (get_called_class(), 'Cursor', 'The CSS cursor during the drag operation.', QType::String),
773:                 new QModelConnectorParam (get_called_class(), 'Delay', 'Time in milliseconds after mousedown until dragging should start. Thisoption can be used to prevent unwanted drags when clicking on anelement.', QType::Integer),
774:                 new QModelConnectorParam (get_called_class(), 'Disabled', 'Disables the draggable if set to true.', QType::Boolean),
775:                 new QModelConnectorParam (get_called_class(), 'Distance', 'Distance in pixels after mousedown the mouse must move before draggingshould start. This option can be used to prevent unwanted drags whenclicking on an element.', QType::Integer),
776:                 new QModelConnectorParam (get_called_class(), 'Grid', 'Snaps the dragging helper to a grid, every x and y pixels. The arraymust be of the form [ x, y ].', QType::ArrayType),
777:                 new QModelConnectorParam (get_called_class(), 'Opacity', 'Opacity for the helper while being dragged.', QType::Integer),
778:                 new QModelConnectorParam (get_called_class(), 'RefreshPositions', 'If set to true, all droppable positions are calculated on everymousemove. _Caution: This solves issues on highly dynamic pages, butdramatically decreases performance._', QType::Boolean),
779:                 new QModelConnectorParam (get_called_class(), 'RevertDuration', 'The duration of the revert animation, in milliseconds. Ignored if therevert option is false.', QType::Integer),
780:                 new QModelConnectorParam (get_called_class(), 'Scope', 'Used to group sets of draggable and droppable items, in addition todroppables accept option. A draggable with the same scope value as adroppable will be accepted by the droppable.', QType::String),
781:                 new QModelConnectorParam (get_called_class(), 'Scroll', 'If set to true, container auto-scrolls while dragging.', QType::Boolean),
782:                 new QModelConnectorParam (get_called_class(), 'ScrollSensitivity', 'Distance in pixels from the edge of the viewport after which theviewport should scroll. Distance is relative to pointer, not thedraggable. Ignored if the scroll option is false.', QType::Integer),
783:                 new QModelConnectorParam (get_called_class(), 'ScrollSpeed', 'The speed at which the window should scroll once the mouse pointergets within the scrollSensitivity distance. Ignored if the scrolloption is false.', QType::Integer),
784:                 new QModelConnectorParam (get_called_class(), 'SnapMode', 'Determines which edges of snap elements the draggable will snap to.Ignored if the snap option is false. Possible values: \"inner\",\"outer\", \"both\".', QType::String),
785:                 new QModelConnectorParam (get_called_class(), 'SnapTolerance', 'The distance in pixels from the snap element edges at which snappingshould occur. Ignored if the snap option is false.', QType::Integer),
786:                 new QModelConnectorParam (get_called_class(), 'ZIndex', 'Z-index for the helper while being dragged.', QType::Integer),
787:             ));
788:         }
789:     }