/Frameworks/Debug/AppKit/rhino.platform/CPSegmentedControl.j

http://github.com/jfahrenkrug/MapKit-HelloWorld · Unknown · 587 lines · 586 code · 1 blank · 0 comment · 0 complexity · 435d5b5ca8c5d65ea86b17b0b6d61098 MD5 · raw file 

    

  1. I;20;Foundation/CPArray.ji;11;CPControl.jc;28921;
    2. 

  2. CPSegmentSwitchTrackingSelectOne = 0;
    3. 

  3. CPSegmentSwitchTrackingSelectAny = 1;
    4. 

  4. CPSegmentSwitchTrackingMomentary = 2;
    5. 

  5. {var the_class = objj_allocateClassPair(CPControl, "CPSegmentedControl"),
    6. 

  6. meta_class = the_class.isa;class_addIvars(the_class, [new objj_ivar("_segments"), new objj_ivar("_themeStates"), new objj_ivar("_selectedSegment"), new objj_ivar("_segmentStyle"), new objj_ivar("_trackingMode"), new objj_ivar("_trackingSegment"), new objj_ivar("_trackingHighlighted")]);
    7. 

  7. objj_registerClassPair(the_class);
    8. 

  8. objj_addClassForBundle(the_class, objj_getBundleWithPath(OBJJ_CURRENT_BUNDLE.path));
    9. 

  9. class_addMethods(the_class, [new objj_method(sel_getUid("initWithFrame:"), function $CPSegmentedControl__initWithFrame_(self, _cmd, aRect)
    10. 

  10. { with(self)
    11. 

  11. {
    12. 

  12.     _segments = [];
    13. 

  13.     _themeStates = [];
    14. 

  14.     self = objj_msgSendSuper({ receiver:self, super_class:objj_getClass("CPControl") }, "initWithFrame:", aRect);
    15. 

  15.     if (self)
    16. 

  16.     {
    17. 

  17.         _selectedSegment = -1;
    18. 

  18.         _trackingMode = CPSegmentSwitchTrackingSelectOne;
    19. 

  19.     }
    20. 

  20.     return self;
    21. 

  21. }
    22. 

  22. }), new objj_method(sel_getUid("selectedTag"), function $CPSegmentedControl__selectedTag(self, _cmd)
    23. 

  23. { with(self)
    24. 

  24. {
    25. 

  25.     return _segments[_selectedSegment].tag;
    26. 

  26. }
    27. 

  27. }), new objj_method(sel_getUid("setSegmentCount:"), function $CPSegmentedControl__setSegmentCount_(self, _cmd, aCount)
    28. 

  28. { with(self)
    29. 

  29. {
    30. 

  30.     if (_segments.length == aCount)
    31. 

  31.         return;
    32. 

  32.     var height = CGRectGetHeight(objj_msgSend(self, "bounds"));
    33. 

  33.     if (_segments.length < aCount)
    34. 

  34.     {
    35. 

  35.         for (var index = _segments.length; index < aCount; ++index)
    36. 

  36.         {
    37. 

  37.             _segments[index] = objj_msgSend(objj_msgSend(_CPSegmentItem, "alloc"), "init");
    38. 

  38.             _themeStates[index] = CPThemeStateNormal;
    39. 

  39.         }
    40. 

  40.     }
    41. 

  41.     else if (aCount < _segments.length)
    42. 

  42.     {
    43. 

  43.         for (var index = aCount; index < _segments.length; ++index)
    44. 

  44.             _segments[index] = nil;
    45. 

  45.     }
    46. 

  46.     if (_selectedSegment < _segments.length)
    47. 

  47.         _selectedSegment = -1;
    48. 

  48.     objj_msgSend(self, "tileWithChangedSegment:", 0);
    49. 

  49. }
    50. 

  50. }), new objj_method(sel_getUid("segmentCount"), function $CPSegmentedControl__segmentCount(self, _cmd)
    51. 

  51. { with(self)
    52. 

  52. {
    53. 

  53.     return _segments.length;
    54. 

  54. }
    55. 

  55. }), new objj_method(sel_getUid("setSelectedSegment:"), function $CPSegmentedControl__setSelectedSegment_(self, _cmd, aSegment)
    56. 

  56. { with(self)
    57. 

  57. {
    58. 

  58.     objj_msgSend(self, "setSelected:forSegment:", YES, aSegment);
    59. 

  59. }
    60. 

  60. }), new objj_method(sel_getUid("selectedSegment"), function $CPSegmentedControl__selectedSegment(self, _cmd)
    61. 

  61. { with(self)
    62. 

  62. {
    63. 

  63.     return _selectedSegment;
    64. 

  64. }
    65. 

  65. }), new objj_method(sel_getUid("selectSegmentWithTag:"), function $CPSegmentedControl__selectSegmentWithTag_(self, _cmd, aTag)
    66. 

  66. { with(self)
    67. 

  67. {
    68. 

  68.     var index = 0;
    69. 

  69.     for (; index < _segments.length; ++index)
    70. 

  70.         if (_segments[index].tag == aTag)
    71. 

  71.         {
    72. 

  72.             objj_msgSend(self, "setSelectedSegment:", index);
    73. 

  73.             return YES;
    74. 

  74.         }
    75. 

  75.     return NO;
    76. 

  76. }
    77. 

  77. }), new objj_method(sel_getUid("isTracking"), function $CPSegmentedControl__isTracking(self, _cmd)
    78. 

  78. { with(self)
    79. 

  79. {
    80. 

  80. }
    81. 

  81. }), new objj_method(sel_getUid("setTrackingMode:"), function $CPSegmentedControl__setTrackingMode_(self, _cmd, aTrackingMode)
    82. 

  82. { with(self)
    83. 

  83. {
    84. 

  84.     if (_trackingMode == aTrackingMode)
    85. 

  85.         return;
    86. 

  86.     _trackingMode = aTrackingMode;
    87. 

  87.     if (_trackingMode == CPSegmentSwitchTrackingSelectOne)
    88. 

  88.     {
    89. 

  89.         var index = 0,
    90. 

  90.             selected = NO;
    91. 

  91.         for (; index < _segments.length; ++index)
    92. 

  92.             if (_segments[index].selected)
    93. 

  93.                 if (selected)
    94. 

  94.                     objj_msgSend(self, "setSelected:forSegment:", NO, index);
    95. 

  95.                 else
    96. 

  96.                     selected = YES;
    97. 

  97.     }
    98. 

  98.     else if (_trackingMode == CPSegmentSwitchTrackingMomentary)
    99. 

  99.     {
    100. 

  100.         var index = 0;
    101. 

  101.         for (; index < _segments.length; ++index)
    102. 

  102.             if (_segments[index].selected)
    103. 

  103.                 objj_msgSend(self, "setSelected:forSegment:", NO, index);
    104. 

  104.     }
    105. 

  105. }
    106. 

  106. }), new objj_method(sel_getUid("trackingMode"), function $CPSegmentedControl__trackingMode(self, _cmd)
    107. 

  107. { with(self)
    108. 

  108. {
    109. 

  109.     return _trackingMode;
    110. 

  110. }
    111. 

  111. }), new objj_method(sel_getUid("setWidth:forSegment:"), function $CPSegmentedControl__setWidth_forSegment_(self, _cmd, aWidth, aSegment)
    112. 

  112. { with(self)
    113. 

  113. {
    114. 

  114.     _segments[aSegment].width = aWidth;
    115. 

  115.     objj_msgSend(self, "tileWithChangedSegment:", aSegment);
    116. 

  116. }
    117. 

  117. }), new objj_method(sel_getUid("widthForSegment:"), function $CPSegmentedControl__widthForSegment_(self, _cmd, aSegment)
    118. 

  118. { with(self)
    119. 

  119. {
    120. 

  120.     return _segments[aSegment].width;
    121. 

  121. }
    122. 

  122. }), new objj_method(sel_getUid("setImage:forSegment:"), function $CPSegmentedControl__setImage_forSegment_(self, _cmd, anImage, aSegment)
    123. 

  123. { with(self)
    124. 

  124. {
    125. 

  125.     var segment = _segments[aSegment];
    126. 

  126.     segment.image = anImage;
    127. 

  127.     objj_msgSend(self, "tileWithChangedSegment:", aSegment);
    128. 

  128. }
    129. 

  129. }), new objj_method(sel_getUid("imageForSegment:"), function $CPSegmentedControl__imageForSegment_(self, _cmd, aSegment)
    130. 

  130. { with(self)
    131. 

  131. {
    132. 

  132.     return _segments[aSegment].image;
    133. 

  133. }
    134. 

  134. }), new objj_method(sel_getUid("setLabel:forSegment:"), function $CPSegmentedControl__setLabel_forSegment_(self, _cmd, aLabel, aSegment)
    135. 

  135. { with(self)
    136. 

  136. {
    137. 

  137.     var segment = _segments[aSegment];
    138. 

  138.     _segments[aSegment].label = aLabel;
    139. 

  139.     objj_msgSend(self, "tileWithChangedSegment:", aSegment);
    140. 

  140. }
    141. 

  141. }), new objj_method(sel_getUid("labelForSegment:"), function $CPSegmentedControl__labelForSegment_(self, _cmd, aSegment)
    142. 

  142. { with(self)
    143. 

  143. {
    144. 

  144.     return _segments[aSegment].label;
    145. 

  145. }
    146. 

  146. }), new objj_method(sel_getUid("setMenu:forSegment:"), function $CPSegmentedControl__setMenu_forSegment_(self, _cmd, aMenu, aSegment)
    147. 

  147. { with(self)
    148. 

  148. {
    149. 

  149.     _segments[aSegment].menu = aMenu;
    150. 

  150. }
    151. 

  151. }), new objj_method(sel_getUid("menuForSegment:"), function $CPSegmentedControl__menuForSegment_(self, _cmd, aSegment)
    152. 

  152. { with(self)
    153. 

  153. {
    154. 

  154.     return _segments[aSegment].menu;
    155. 

  155. }
    156. 

  156. }), new objj_method(sel_getUid("setSelected:forSegment:"), function $CPSegmentedControl__setSelected_forSegment_(self, _cmd, isSelected, aSegment)
    157. 

  157. { with(self)
    158. 

  158. {
    159. 

  159.     var segment = _segments[aSegment];
    160. 

  160.     if (segment.selected == isSelected)
    161. 

  161.         return;
    162. 

  162.     segment.selected = isSelected;
    163. 

  163.     _themeStates[aSegment] = isSelected ? CPThemeStateSelected : CPThemeStateNormal;
    164. 

  164.     if (isSelected)
    165. 

  165.     {
    166. 

  166.         var oldSelectedSegment = _selectedSegment;
    167. 

  167.         _selectedSegment = aSegment;
    168. 

  168.         if (_trackingMode == CPSegmentSwitchTrackingSelectOne && oldSelectedSegment != aSegment && oldSelectedSegment != -1)
    169. 

  169.         {
    170. 

  170.             _segments[oldSelectedSegment].selected = NO;
    171. 

  171.             _themeStates[oldSelectedSegment] = CPThemeStateNormal;
    172. 

  172.             objj_msgSend(self, "drawSegmentBezel:highlight:", oldSelectedSegment, NO);
    173. 

  173.         }
    174. 

  174.     }
    175. 

  175.     if (_trackingMode != CPSegmentSwitchTrackingMomentary)
    176. 

  176.         objj_msgSend(self, "drawSegmentBezel:highlight:", aSegment, NO);
    177. 

  177.     objj_msgSend(self, "setNeedsLayout");
    178. 

  178.     objj_msgSend(self, "setNeedsDisplay:", YES);
    179. 

  179. }
    180. 

  180. }), new objj_method(sel_getUid("isSelectedForSegment:"), function $CPSegmentedControl__isSelectedForSegment_(self, _cmd, aSegment)
    181. 

  181. { with(self)
    182. 

  182. {
    183. 

  183.     return _segments[aSegment].selected;
    184. 

  184. }
    185. 

  185. }), new objj_method(sel_getUid("setEnabled:forSegment:"), function $CPSegmentedControl__setEnabled_forSegment_(self, _cmd, isEnabled, aSegment)
    186. 

  186. { with(self)
    187. 

  187. {
    188. 

  188.     _segments[aSegment].enabled = isEnabled;
    189. 

  189.     objj_msgSend(self, "setNeedsLayout");
    190. 

  190.     objj_msgSend(self, "setNeedsDisplay:", YES);
    191. 

  191. }
    192. 

  192. }), new objj_method(sel_getUid("isEnabledForSegment:"), function $CPSegmentedControl__isEnabledForSegment_(self, _cmd, aSegment)
    193. 

  193. { with(self)
    194. 

  194. {
    195. 

  195.     return _segments[aSegment].enabled;
    196. 

  196. }
    197. 

  197. }), new objj_method(sel_getUid("setTag:forSegment:"), function $CPSegmentedControl__setTag_forSegment_(self, _cmd, aTag, aSegment)
    198. 

  198. { with(self)
    199. 

  199. {
    200. 

  200.     _segments[aSegment].tag = aTag;
    201. 

  201. }
    202. 

  202. }), new objj_method(sel_getUid("tagForSegment:"), function $CPSegmentedControl__tagForSegment_(self, _cmd, aSegment)
    203. 

  203. { with(self)
    204. 

  204. {
    205. 

  205.     return _segments[aSegment].tag;
    206. 

  206. }
    207. 

  207. }), new objj_method(sel_getUid("drawSegmentBezel:highlight:"), function $CPSegmentedControl__drawSegmentBezel_highlight_(self, _cmd, aSegment, shouldHighlight)
    208. 

  208. { with(self)
    209. 

  209. {
    210. 

  210.     if (shouldHighlight)
    211. 

  211.         _themeStates[aSegment] |= CPThemeStateHighlighted;
    212. 

  212.     else
    213. 

  213.         _themeStates[aSegment] &= ~CPThemeStateHighlighted;
    214. 

  214.     objj_msgSend(self, "setNeedsLayout");
    215. 

  215.     objj_msgSend(self, "setNeedsDisplay:", YES);
    216. 

  216. }
    217. 

  217. }), new objj_method(sel_getUid("_leftOffsetForSegment:"), function $CPSegmentedControl___leftOffsetForSegment_(self, _cmd, segment)
    218. 

  218. { with(self)
    219. 

  219. {
    220. 

  220.     var bezelInset = objj_msgSend(self, "currentValueForThemeAttribute:", "bezel-inset");
    221. 

  221.     if (segment == 0)
    222. 

  222.         return bezelInset.left;
    223. 

  223.     var thickness = objj_msgSend(self, "currentValueForThemeAttribute:", "divider-thickness");
    224. 

  224.     return objj_msgSend(self, "_leftOffsetForSegment:", segment - 1) + objj_msgSend(self, "widthForSegment:", segment - 1) + thickness;
    225. 

  225. }
    226. 

  226. }), new objj_method(sel_getUid("rectForEphemeralSubviewNamed:"), function $CPSegmentedControl__rectForEphemeralSubviewNamed_(self, _cmd, aName)
    227. 

  227. { with(self)
    228. 

  228. {
    229. 

  229.     var height = objj_msgSend(self, "currentValueForThemeAttribute:", "default-height"),
    230. 

  230.         contentInset = objj_msgSend(self, "currentValueForThemeAttribute:", "content-inset"),
    231. 

  231.         bezelInset = objj_msgSend(self, "currentValueForThemeAttribute:", "bezel-inset"),
    232. 

  232.         bounds = objj_msgSend(self, "bounds");
    233. 

  233.     if (aName === "left-segment-bezel")
    234. 

  234.     {
    235. 

  235.         return CGRectMake(bezelInset.left, bezelInset.top, contentInset.left, height);
    236. 

  236.     }
    237. 

  237.     else if (aName === "right-segment-bezel")
    238. 

  238.     {
    239. 

  239.         return CGRectMake(CGRectGetMaxX(bounds) - contentInset.right - bezelInset.right, bezelInset.top, contentInset.right, height);
    240. 

  240.     }
    241. 

  241.     else if (aName.substring(0, "segment-bezel".length) == "segment-bezel")
    242. 

  242.     {
    243. 

  243.         var segment = parseInt(aName.substring("segment-bezel-".length), 10),
    244. 

  244.             frame = CGRectCreateCopy(_segments[segment].frame);
    245. 

  245.         if (segment == 0)
    246. 

  246.         {
    247. 

  247.             frame.origin.x += contentInset.left;
    248. 

  248.             frame.size.width -= contentInset.left;
    249. 

  249.         }
    250. 

  250.         if (segment == _segments.length - 1)
    251. 

  251.             frame.size.width -= contentInset.right;
    252. 

  252.         return frame;
    253. 

  253.     }
    254. 

  254.     else if (aName.substring(0, "divider-bezel".length) == "divider-bezel")
    255. 

  255.     {
    256. 

  256.         var segment = parseInt(aName.substring("divider-bezel-".length), 10),
    257. 

  257.             width = objj_msgSend(self, "widthForSegment:", segment),
    258. 

  258.             left = objj_msgSend(self, "_leftOffsetForSegment:", segment),
    259. 

  259.             thickness = objj_msgSend(self, "currentValueForThemeAttribute:", "divider-thickness");
    260. 

  260.         return CGRectMake(left + width, bezelInset.top, thickness, height);
    261. 

  261.     }
    262. 

  262.     else if (aName.substring(0, "segment-content".length) == "segment-content")
    263. 

  263.     {
    264. 

  264.         var segment = parseInt(aName.substring("segment-content-".length), 10);
    265. 

  265.         return objj_msgSend(self, "contentFrameForSegment:", segment);
    266. 

  266.     }
    267. 

  267.     return objj_msgSendSuper({ receiver:self, super_class:objj_getClass("CPControl") }, "rectForEphemeralSubviewNamed:", aName);
    268. 

  268. }
    269. 

  269. }), new objj_method(sel_getUid("createEphemeralSubviewNamed:"), function $CPSegmentedControl__createEphemeralSubviewNamed_(self, _cmd, aName)
    270. 

  270. { with(self)
    271. 

  271. {
    272. 

  272.     if (aName.substring(0, "segment-content".length) == "segment-content")
    273. 

  273.         return objj_msgSend(objj_msgSend(_CPImageAndTextView, "alloc"), "initWithFrame:", { origin: { x:0.0, y:0.0 }, size: { width:0.0, height:0.0 } });
    274. 

  274.     return objj_msgSend(objj_msgSend(CPView, "alloc"), "initWithFrame:", { origin: { x:0.0, y:0.0 }, size: { width:0.0, height:0.0 } });
    275. 

  275. }
    276. 

  276. }), new objj_method(sel_getUid("layoutSubviews"), function $CPSegmentedControl__layoutSubviews(self, _cmd)
    277. 

  277. { with(self)
    278. 

  278. {
    279. 

  279.     var leftCapColor = objj_msgSend(self, "valueForThemeAttribute:inState:", "left-segment-bezel-color", _themeStates[0]);
    280. 

  280.     var leftBezelView = objj_msgSend(self, "layoutEphemeralSubviewNamed:positioned:relativeToEphemeralSubviewNamed:", "left-segment-bezel", CPWindowBelow, nil);
    281. 

  281.     objj_msgSend(leftBezelView, "setBackgroundColor:", leftCapColor);
    282. 

  282.     var rightCapColor = objj_msgSend(self, "valueForThemeAttribute:inState:", "right-segment-bezel-color", _themeStates[_themeStates.length - 1]);
    283. 

  283.     var rightBezelView = objj_msgSend(self, "layoutEphemeralSubviewNamed:positioned:relativeToEphemeralSubviewNamed:", "right-segment-bezel", CPWindowBelow, nil);
    284. 

  284.     objj_msgSend(rightBezelView, "setBackgroundColor:", rightCapColor);
    285. 

  285.     for (var i=0, count = _themeStates.length; i<count; i++)
    286. 

  286.     {
    287. 

  287.         var themeState = _themeStates[i];
    288. 

  288.         themeState |= _themeState & CPThemeStateDisabled;
    289. 

  289.         var bezelColor = objj_msgSend(self, "valueForThemeAttribute:inState:", "center-segment-bezel-color", themeState);
    290. 

  290.         var bezelView = objj_msgSend(self, "layoutEphemeralSubviewNamed:positioned:relativeToEphemeralSubviewNamed:", "segment-bezel-"+i, CPWindowBelow, nil);
    291. 

  291.         objj_msgSend(bezelView, "setBackgroundColor:", bezelColor);
    292. 

  292.         var segment = _segments[i];
    293. 

  293.         var contentView = objj_msgSend(self, "layoutEphemeralSubviewNamed:positioned:relativeToEphemeralSubviewNamed:", "segment-content-"+i, CPWindowAbove, "segment-bezel-"+i);
    294. 

  294.         objj_msgSend(contentView, "setText:", segment.label);
    295. 

  295.         objj_msgSend(contentView, "setImage:", segment.image);
    296. 

  296.         objj_msgSend(contentView, "setFont:", objj_msgSend(self, "valueForThemeAttribute:inState:", "font", themeState));
    297. 

  297.         objj_msgSend(contentView, "setTextColor:", objj_msgSend(self, "valueForThemeAttribute:inState:", "text-color", themeState));
    298. 

  298.         objj_msgSend(contentView, "setAlignment:", objj_msgSend(self, "valueForThemeAttribute:inState:", "alignment", themeState));
    299. 

  299.         objj_msgSend(contentView, "setVerticalAlignment:", objj_msgSend(self, "valueForThemeAttribute:inState:", "vertical-alignment", themeState));
    300. 

  300.         objj_msgSend(contentView, "setLineBreakMode:", objj_msgSend(self, "valueForThemeAttribute:inState:", "line-break-mode", themeState));
    301. 

  301.         objj_msgSend(contentView, "setTextShadowColor:", objj_msgSend(self, "valueForThemeAttribute:inState:", "text-shadow-color", themeState));
    302. 

  302.         objj_msgSend(contentView, "setTextShadowOffset:", objj_msgSend(self, "valueForThemeAttribute:inState:", "text-shadow-offset", themeState));
    303. 

  303.         objj_msgSend(contentView, "setImageScaling:", objj_msgSend(self, "valueForThemeAttribute:inState:", "image-scaling", themeState));
    304. 

  304.         if (segment.image && segment.label)
    305. 

  305.             objj_msgSend(contentView, "setImagePosition:", objj_msgSend(self, "valueForThemeAttribute:inState:", "image-position", themeState));
    306. 

  306.         else if (segment.image)
    307. 

  307.             objj_msgSend(contentView, "setImagePosition:", CPImageOnly);
    308. 

  308.         if (i == count - 1)
    309. 

  309.             continue;
    310. 

  310.         var borderState = _themeStates[i] | _themeStates[i+1];
    311. 

  311.         borderState = (borderState & CPThemeStateSelected & ~CPThemeStateHighlighted) ? CPThemeStateSelected : CPThemeStateNormal;
    312. 

  312.         borderState |= _themeState & CPThemeStateDisabled;
    313. 

  313.         var borderColor = objj_msgSend(self, "valueForThemeAttribute:inState:", "divider-bezel-color", borderState);
    314. 

  314.         var borderView = objj_msgSend(self, "layoutEphemeralSubviewNamed:positioned:relativeToEphemeralSubviewNamed:", "divider-bezel-"+i, CPWindowBelow, nil);
    315. 

  315.         objj_msgSend(borderView, "setBackgroundColor:", borderColor);
    316. 

  316.     }
    317. 

  317. }
    318. 

  318. }), new objj_method(sel_getUid("drawSegment:highlight:"), function $CPSegmentedControl__drawSegment_highlight_(self, _cmd, aSegment, shouldHighlight)
    319. 

  319. { with(self)
    320. 

  320. {
    321. 

  321. }
    322. 

  322. }), new objj_method(sel_getUid("tileWithChangedSegment:"), function $CPSegmentedControl__tileWithChangedSegment_(self, _cmd, aSegment)
    323. 

  323. { with(self)
    324. 

  324. {
    325. 

  325.     if (aSegment >= _segments.length)
    326. 

  326.         return;
    327. 

  327.     var segment = _segments[aSegment],
    328. 

  328.         segmentWidth = segment.width,
    329. 

  329.         themeState = _themeStates[aSegment] | (_themeState & CPThemeStateDisabled),
    330. 

  330.         contentInset = objj_msgSend(self, "valueForThemeAttribute:inState:", "content-inset", themeState),
    331. 

  331.         font = objj_msgSend(self, "valueForThemeAttribute:inState:", "font", themeState);
    332. 

  332.     if (!segmentWidth)
    333. 

  333.     {
    334. 

  334.         if (segment.image && segment.label)
    335. 

  335.             segmentWidth = objj_msgSend(segment.label, "sizeWithFont:", font).width + objj_msgSend(segment.image, "size").width + contentInset.left + contentInset.right;
    336. 

  336.         else if (segment.image)
    337. 

  337.             segmentWidth = objj_msgSend(segment.image, "size").width + contentInset.left + contentInset.right;
    338. 

  338.         else if (segment.label)
    339. 

  339.             segmentWidth = objj_msgSend(segment.label, "sizeWithFont:", font).width + contentInset.left + contentInset.right;
    340. 

  340.         else
    341. 

  341.             segmentWidth = 0.0;
    342. 

  342.     }
    343. 

  343.     var delta = segmentWidth - CGRectGetWidth(segment.frame);
    344. 

  344.     if (!delta)
    345. 

  345.         return;
    346. 

  346.     var frame = objj_msgSend(self, "frame");
    347. 

  347.     objj_msgSend(self, "setFrameSize:", CGSizeMake(CGRectGetWidth(frame) + delta, CGRectGetHeight(frame)));
    348. 

  348.     segment.width = segmentWidth;
    349. 

  349.     segment.frame = objj_msgSend(self, "frameForSegment:", aSegment);;
    350. 

  350.     var index = aSegment + 1;
    351. 

  351.     for (; index < _segments.length; ++index)
    352. 

  352.     {
    353. 

  353.         _segments[index].frame.origin.x += delta;
    354. 

  354.         objj_msgSend(self, "drawSegmentBezel:highlight:", index, NO);
    355. 

  355.         objj_msgSend(self, "drawSegment:highlight:", index, NO);
    356. 

  356.     }
    357. 

  357.     objj_msgSend(self, "drawSegmentBezel:highlight:", aSegment, NO);
    358. 

  358.     objj_msgSend(self, "drawSegment:highlight:", aSegment, NO);
    359. 

  359.     objj_msgSend(self, "setNeedsLayout");
    360. 

  360.     objj_msgSend(self, "setNeedsDisplay:", YES);
    361. 

  361. }
    362. 

  362. }), new objj_method(sel_getUid("frameForSegment:"), function $CPSegmentedControl__frameForSegment_(self, _cmd, aSegment)
    363. 

  363. { with(self)
    364. 

  364. {
    365. 

  365.     return objj_msgSend(self, "bezelFrameForSegment:", aSegment);
    366. 

  366. }
    367. 

  367. }), new objj_method(sel_getUid("bezelFrameForSegment:"), function $CPSegmentedControl__bezelFrameForSegment_(self, _cmd, aSegment)
    368. 

  368. { with(self)
    369. 

  369. {
    370. 

  370.     var height = objj_msgSend(self, "currentValueForThemeAttribute:", "default-height"),
    371. 

  371.         bezelInset = objj_msgSend(self, "currentValueForThemeAttribute:", "bezel-inset"),
    372. 

  372.         width = objj_msgSend(self, "widthForSegment:", aSegment),
    373. 

  373.         left = objj_msgSend(self, "_leftOffsetForSegment:", aSegment);
    374. 

  374.     return CGRectMake(left, bezelInset.top, width, height);
    375. 

  375. }
    376. 

  376. }), new objj_method(sel_getUid("contentFrameForSegment:"), function $CPSegmentedControl__contentFrameForSegment_(self, _cmd, aSegment)
    377. 

  377. { with(self)
    378. 

  378. {
    379. 

  379.     var height = objj_msgSend(self, "currentValueForThemeAttribute:", "default-height"),
    380. 

  380.         contentInset = objj_msgSend(self, "currentValueForThemeAttribute:", "content-inset"),
    381. 

  381.         width = objj_msgSend(self, "widthForSegment:", aSegment),
    382. 

  382.         left = objj_msgSend(self, "_leftOffsetForSegment:", aSegment);
    383. 

  383.     return CGRectMake(left + contentInset.left, contentInset.top, width - contentInset.left - contentInset.right, height - contentInset.top - contentInset.bottom);
    384. 

  384. }
    385. 

  385. }), new objj_method(sel_getUid("testSegment:"), function $CPSegmentedControl__testSegment_(self, _cmd, aPoint)
    386. 

  386. { with(self)
    387. 

  387. {
    388. 

  388.     var location = objj_msgSend(self, "convertPoint:fromView:", aPoint, nil),
    389. 

  389.         count = _segments.length;
    390. 

  390.     while (count--)
    391. 

  391.         if (CGRectContainsPoint(_segments[count].frame, aPoint))
    392. 

  392.             return count;
    393. 

  393.     return -1;
    394. 

  394. }
    395. 

  395. }), new objj_method(sel_getUid("mouseDown:"), function $CPSegmentedControl__mouseDown_(self, _cmd, anEvent)
    396. 

  396. { with(self)
    397. 

  397. {
    398. 

  398.     if (!objj_msgSend(self, "isEnabled"))
    399. 

  399.         return;
    400. 

  400.     objj_msgSend(self, "trackSegment:", anEvent);
    401. 

  401. }
    402. 

  402. }), new objj_method(sel_getUid("mouseUp:"), function $CPSegmentedControl__mouseUp_(self, _cmd, anEvent)
    403. 

  403. { with(self)
    404. 

  404. {
    405. 

  405. }
    406. 

  406. }), new objj_method(sel_getUid("trackSegment:"), function $CPSegmentedControl__trackSegment_(self, _cmd, anEvent)
    407. 

  407. { with(self)
    408. 

  408. {
    409. 

  409.     var type = objj_msgSend(anEvent, "type"),
    410. 

  410.         location = objj_msgSend(self, "convertPoint:fromView:", objj_msgSend(anEvent, "locationInWindow"), nil);
    411. 

  411.     if (type == CPLeftMouseUp)
    412. 

  412.     {
    413. 

  413.         if (_trackingSegment == -1)
    414. 

  414.             return;
    415. 

  415.         if (CGRectContainsPoint(_segments[_trackingSegment].frame, location))
    416. 

  416.         {
    417. 

  417.             if (_trackingMode == CPSegmentSwitchTrackingSelectAny)
    418. 

  418.             {
    419. 

  419.                 objj_msgSend(self, "setSelected:forSegment:", !objj_msgSend(self, "isSelectedForSegment:", _trackingSegment), _trackingSegment);
    420. 

  420.                 _selectedSegment = _trackingSegment;
    421. 

  421.             }
    422. 

  422.             else
    423. 

  423.                 objj_msgSend(self, "setSelected:forSegment:", YES, _trackingSegment);
    424. 

  424.             objj_msgSend(self, "sendAction:to:", objj_msgSend(self, "action"), objj_msgSend(self, "target"));
    425. 

  425.             if (_trackingMode == CPSegmentSwitchTrackingMomentary)
    426. 

  426.             {
    427. 

  427.                 objj_msgSend(self, "setSelected:forSegment:", NO, _trackingSegment);
    428. 

  428.                 _selectedSegment = -1;
    429. 

  429.             }
    430. 

  430.         }
    431. 

  431.         objj_msgSend(self, "drawSegmentBezel:highlight:", _trackingSegment, NO);
    432. 

  432.         _trackingSegment = -1;
    433. 

  433.         return;
    434. 

  434.     }
    435. 

  435.     if (type == CPLeftMouseDown)
    436. 

  436.     {
    437. 

  437.         _trackingHighlighted = YES;
    438. 

  438.         _trackingSegment = objj_msgSend(self, "testSegment:", location);
    439. 

  439.         objj_msgSend(self, "drawSegmentBezel:highlight:", _trackingSegment, YES);
    440. 

  440.     }
    441. 

  441.     else if (type == CPLeftMouseDragged)
    442. 

  442.     {
    443. 

  443.         if (_trackingSegment == -1)
    444. 

  444.             return;
    445. 

  445.         var highlighted = CGRectContainsPoint(_segments[_trackingSegment].frame, location);
    446. 

  446.         if (highlighted != _trackingHighlighted)
    447. 

  447.         {
    448. 

  448.             _trackingHighlighted = highlighted;
    449. 

  449.             objj_msgSend(self, "drawSegmentBezel:highlight:", _trackingSegment, _trackingHighlighted);
    450. 

  450.         }
    451. 

  451.     }
    452. 

  452.     objj_msgSend(CPApp, "setTarget:selector:forNextEventMatchingMask:untilDate:inMode:dequeue:", self, sel_getUid("trackSegment:"), CPLeftMouseDraggedMask | CPLeftMouseUpMask, nil, nil, YES);
    453. 

  453. }
    454. 

  454. }), new objj_method(sel_getUid("setFont:"), function $CPSegmentedControl__setFont_(self, _cmd, aFont)
    455. 

  455. { with(self)
    456. 

  456. {
    457. 

  457.     objj_msgSendSuper({ receiver:self, super_class:objj_getClass("CPControl") }, "setFont:", aFont);
    458. 

  458.     objj_msgSend(self, "tileWithChangedSegment:", 0);
    459. 

  459. }
    460. 

  460. })]);
    461. 

  461. class_addMethods(meta_class, [new objj_method(sel_getUid("themeClass"), function $CPSegmentedControl__themeClass(self, _cmd)
    462. 

  462. { with(self)
    463. 

  463. {
    464. 

  464.     return "segmented-control";
    465. 

  465. }
    466. 

  466. }), new objj_method(sel_getUid("themeAttributes"), function $CPSegmentedControl__themeAttributes(self, _cmd)
    467. 

  467. { with(self)
    468. 

  468. {
    469. 

  469.     return objj_msgSend(CPDictionary, "dictionaryWithObjects:forKeys:", [CPCenterTextAlignment, CPCenterVerticalTextAlignment, CPImageLeft, CPScaleNone, { top:(0), right:(0), bottom:(0), left:(0) }, { top:(0), right:(0), bottom:(0), left:(0) }, nil, nil, nil, nil, 1.0, 24.0], ["alignment", "vertical-alignment", "image-position", "image-scaling", "bezel-inset", "content-inset", "left-segment-bezel-color", "right-segment-bezel-color", "center-segment-bezel-color", "divider-bezel-color", "divider-thickness", "default-height"]);
    470. 

  470. }
    471. 

  471. })]);
    472. 

  472. }
    473. 

  473. var CPSegmentedControlSegmentsKey = "CPSegmentedControlSegmentsKey",
    474. 

  474.     CPSegmentedControlSelectedKey = "CPSegmentedControlSelectedKey",
    475. 

  475.     CPSegmentedControlSegmentStyleKey = "CPSegmentedControlSegmentStyleKey",
    476. 

  476.     CPSegmentedControlTrackingModeKey = "CPSegmentedControlTrackingModeKey";
    477. 

  477. {
    478. 

  478. var the_class = objj_getClass("CPSegmentedControl")
    479. 

  479. if(!the_class) objj_exception_throw(new objj_exception(OBJJClassNotFoundException, "*** Could not find definition for class \"CPSegmentedControl\""));
    480. 

  480. var meta_class = the_class.isa;class_addMethods(the_class, [new objj_method(sel_getUid("initWithCoder:"), function $CPSegmentedControl__initWithCoder_(self, _cmd, aCoder)
    481. 

  481. { with(self)
    482. 

  482. {
    483. 

  483.     self = objj_msgSendSuper({ receiver:self, super_class:objj_getClass("CPControl") }, "initWithCoder:", aCoder);
    484. 

  484.     if (self)
    485. 

  485.     {
    486. 

  486.         var frame = objj_msgSend(self, "frame"),
    487. 

  487.             originalWidth = frame.size.width;
    488. 

  488.         frame.size.width = 0;
    489. 

  489.         objj_msgSend(self, "setFrame:", frame);
    490. 

  490.         _segments = objj_msgSend(aCoder, "decodeObjectForKey:", CPSegmentedControlSegmentsKey);
    491. 

  491.         _segmentStyle = objj_msgSend(aCoder, "decodeIntForKey:", CPSegmentedControlSegmentStyleKey);
    492. 

  492.         _themeStates = [];
    493. 

  493.         if (objj_msgSend(aCoder, "containsValueForKey:", CPSegmentedControlSelectedKey))
    494. 

  494.             _selectedSegment = objj_msgSend(aCoder, "decodeIntForKey:", CPSegmentedControlSelectedKey);
    495. 

  495.         else
    496. 

  496.             _selectedSegment = -1;
    497. 

  497.         if (objj_msgSend(aCoder, "containsValueForKey:", CPSegmentedControlTrackingModeKey))
    498. 

  498.             _trackingMode = objj_msgSend(aCoder, "decodeIntForKey:", CPSegmentedControlTrackingModeKey);
    499. 

  499.         else
    500. 

  500.             _trackingMode = CPSegmentSwitchTrackingSelectOne;
    501. 

  501.         for (var i = 0; i < _segments.length; i++)
    502. 

  502.         {
    503. 

  503.             _themeStates[i] = _segments[i].selected ? CPThemeStateSelected : CPThemeStateNormal;
    504. 

  504.             objj_msgSend(self, "tileWithChangedSegment:", i);
    505. 

  505.         }
    506. 

  506.         var difference = MAX(originalWidth - objj_msgSend(self, "frame").size.width, 0.0),
    507. 

  507.             remainingWidth = FLOOR(difference / _segments.length);
    508. 

  508.         for (var i=0; i < _segments.length; i++)
    509. 

  509.             objj_msgSend(self, "setWidth:forSegment:", _segments[i].width + remainingWidth, i);
    510. 

  510.         objj_msgSend(self, "tileWithChangedSegment:", 0);
    511. 

  511.     }
    512. 

  512.     return self;
    513. 

  513. }
    514. 

  514. }), new objj_method(sel_getUid("encodeWithCoder:"), function $CPSegmentedControl__encodeWithCoder_(self, _cmd, aCoder)
    515. 

  515. { with(self)
    516. 

  516. {
    517. 

  517.     objj_msgSendSuper({ receiver:self, super_class:objj_getClass("CPControl") }, "encodeWithCoder:", aCoder);
    518. 

  518.     objj_msgSend(aCoder, "encodeObject:forKey:", _segments, CPSegmentedControlSegmentsKey);
    519. 

  519.     objj_msgSend(aCoder, "encodeInt:forKey:", _selectedSegment, CPSegmentedControlSelectedKey);
    520. 

  520.     objj_msgSend(aCoder, "encodeInt:forKey:", _segmentStyle, CPSegmentedControlSegmentStyleKey);
    521. 

  521.     objj_msgSend(aCoder, "encodeInt:forKey:", _trackingMode, CPSegmentedControlTrackingModeKey);
    522. 

  522. }
    523. 

  523. })]);
    524. 

  524. }
    525. 

  525. {var the_class = objj_allocateClassPair(CPObject, "_CPSegmentItem"),
    526. 

  526. meta_class = the_class.isa;class_addIvars(the_class, [new objj_ivar("image"), new objj_ivar("label"), new objj_ivar("menu"), new objj_ivar("selected"), new objj_ivar("enabled"), new objj_ivar("tag"), new objj_ivar("width"), new objj_ivar("frame")]);
    527. 

  527. objj_registerClassPair(the_class);
    528. 

  528. objj_addClassForBundle(the_class, objj_getBundleWithPath(OBJJ_CURRENT_BUNDLE.path));
    529. 

  529. class_addMethods(the_class, [new objj_method(sel_getUid("init"), function $_CPSegmentItem__init(self, _cmd)
    530. 

  530. { with(self)
    531. 

  531. {
    532. 

  532.     if (self = objj_msgSendSuper({ receiver:self, super_class:objj_getClass("CPObject") }, "init"))
    533. 

  533.     {
    534. 

  534.         image = nil;
    535. 

  535.         label = "";
    536. 

  536.         menu = nil;
    537. 

  537.         selected = NO;
    538. 

  538.         enabled = NO;
    539. 

  539.         tag = 0;
    540. 

  540.         width = 0;
    541. 

  541.         frame = CGRectMakeZero();
    542. 

  542.     }
    543. 

  543.     return self;
    544. 

  544. }
    545. 

  545. })]);
    546. 

  546. }
    547. 

  547. var CPSegmentItemImageKey = "CPSegmentItemImageKey",
    548. 

  548.     CPSegmentItemLabelKey = "CPSegmentItemLabelKey",
    549. 

  549.     CPSegmentItemMenuKey = "CPSegmentItemMenuKey",
    550. 

  550.     CPSegmentItemSelectedKey = "CPSegmentItemSelectedKey",
    551. 

  551.     CPSegmentItemEnabledKey = "CPSegmentItemEnabledKey",
    552. 

  552.     CPSegmentItemTagKey = "CPSegmentItemTagKey",
    553. 

  553.     CPSegmentItemWidthKey = "CPSegmentItemWidthKey";
    554. 

  554. {
    555. 

  555. var the_class = objj_getClass("_CPSegmentItem")
    556. 

  556. if(!the_class) objj_exception_throw(new objj_exception(OBJJClassNotFoundException, "*** Could not find definition for class \"_CPSegmentItem\""));
    557. 

  557. var meta_class = the_class.isa;class_addMethods(the_class, [new objj_method(sel_getUid("initWithCoder:"), function $_CPSegmentItem__initWithCoder_(self, _cmd, aCoder)
    558. 

  558. { with(self)
    559. 

  559. {
    560. 

  560.     self = objj_msgSendSuper({ receiver:self, super_class:objj_getClass("CPObject") }, "init");
    561. 

  561.     if (self)
    562. 

  562.     {
    563. 

  563.         image = objj_msgSend(aCoder, "decodeObjectForKey:", CPSegmentItemImageKey);
    564. 

  564.         label = objj_msgSend(aCoder, "decodeObjectForKey:", CPSegmentItemLabelKey);
    565. 

  565.         menu = objj_msgSend(aCoder, "decodeObjectForKey:", CPSegmentItemMenuKey);
    566. 

  566.         selected = objj_msgSend(aCoder, "decodeBoolForKey:", CPSegmentItemSelectedKey);
    567. 

  567.         enabled = objj_msgSend(aCoder, "decodeBoolForKey:", CPSegmentItemEnabledKey);
    568. 

  568.         tag = objj_msgSend(aCoder, "decodeIntForKey:", CPSegmentItemTagKey);
    569. 

  569.         width = objj_msgSend(aCoder, "decodeFloatForKey:", CPSegmentItemWidthKey);
    570. 

  570.         frame = CGRectMakeZero();
    571. 

  571.     }
    572. 

  572.     return self;
    573. 

  573. }
    574. 

  574. }), new objj_method(sel_getUid("encodeWithCoder:"), function $_CPSegmentItem__encodeWithCoder_(self, _cmd, aCoder)
    575. 

  575. { with(self)
    576. 

  576. {
    577. 

  577.     objj_msgSend(aCoder, "encodeObject:forKey:", image, CPSegmentItemImageKey);
    578. 

  578.     objj_msgSend(aCoder, "encodeObject:forKey:", label, CPSegmentItemLabelKey);
    579. 

  579.     objj_msgSend(aCoder, "encodeObject:forKey:", menu, CPSegmentItemMenuKey);
    580. 

  580.     objj_msgSend(aCoder, "encodeBool:forKey:", selected, CPSegmentItemSelectedKey);
    581. 

  581.     objj_msgSend(aCoder, "encodeBool:forKey:", enabled, CPSegmentItemEnabledKey);
    582. 

  582.     objj_msgSend(aCoder, "encodeInt:forKey:", tag, CPSegmentItemTagKey);
    583. 

  583.     objj_msgSend(aCoder, "encodeFloat:forKey:", width, CPSegmentItemWidthKey);
    584. 

  584. }
    585. 

  585. })]);
    586. 

  586. }
    587.