lib/ios/ui/ui.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 # Implementation of `app::ui` for iOS
  16 module ui
  17
  18 import app::ui
  19
  20 import ios
  21 import uikit
  22
  23 in "ObjC" `{
  24 // Objective-C object receiving callbacks from UI events
  25 @interface NitCallbackReference: NSObject
  26
  27         // Nit object target of the callbacks from UI events
  28         @property (nonatomic) Button nit_button;
  29
  30         // Actual callback method
  31         -(void) nitOnEvent: (UIButton*) sender;
  32 @end
  33
  34 @implementation NitCallbackReference
  35
  36         -(void) nitOnEvent: (UIButton*) sender {
  37                 Button_on_click(self.nit_button);
  38         }
  39 @end
  40
  41 // Proxy for both delegates of UITableView relaying all callbacks to `nit_list_layout`
  42 @interface UITableViewAndDataSource: NSObject <UITableViewDelegate, UITableViewDataSource>
  43
  44         // Nit object receiving the callbacks
  45         @property ListLayout nit_list_layout;
  46
  47         // List of native views added to this list view from the Nit side
  48         @property NSMutableArray *views;
  49 @end
  50
  51 @implementation UITableViewAndDataSource
  52
  53         - (id)init
  54         {
  55                 self = [super init];
  56                 self.views = [[NSMutableArray alloc] initWithCapacity:8];
  57                 return self;
  58         }
  59
  60         - (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView {
  61                 return ListLayout_number_of_sections_in_table_view(self.nit_list_layout, tableView);
  62         }
  63
  64         - (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section {
  65                 return ListLayout_number_of_rows_in_section(self.nit_list_layout, tableView, section);
  66         }
  67
  68         - (NSString *)tableView:(UITableView *)tableView titleForHeaderInSection:(NSInteger)section {
  69                 return ListLayout_title_for_header_in_section(self.nit_list_layout, tableView, section);
  70         }
  71
  72         - (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath {
  73                 return ListLayout_cell_for_row_at_index_path(self.nit_list_layout, tableView, indexPath);
  74         }
  75 @end
  76 `}
  77
  78 redef class App
  79         redef fun did_finish_launching_with_options
  80         do
  81                 super
  82                 window.native.make_key_and_visible
  83                 return true
  84         end
  85
  86         redef fun window=(window)
  87         do
  88                 app_delegate.window = window.native
  89                 super
  90         end
  91 end
  92
  93 redef class AppDelegate
  94
  95         # The main application window, must be set by `App::on_create`
  96         fun window: UIWindow in "ObjC" `{ return [self window]; `}
  97
  98         # The main application window, must be set by `App::on_create`
  99         fun window=(window: UIWindow) in "ObjC" `{ self.window = window; `}
 100 end
 101
 102 redef class Control
 103
 104         # Native implementation of this control
 105         fun native: NATIVE is abstract
 106
 107         # Type of the `native` implementation of this control
 108         type NATIVE: NSObject
 109 end
 110
 111 redef class View
 112         redef type NATIVE: UIView
 113
 114         redef var enabled = null is lazy
 115 end
 116
 117 redef class CompositeControl
 118
 119         redef fun remove(view)
 120         do
 121                 super
 122
 123                 var native_view = view.native
 124                 assert native_view isa UIView
 125                 native_view.remove_from_superview
 126         end
 127 end
 128
 129 redef class Window
 130
 131         redef type NATIVE: UIWindow
 132         redef var native = new UIWindow
 133
 134         init do native.background_color = new UIColor.white_color
 135
 136         redef fun add(view)
 137         do
 138                 super
 139
 140                 var native_view = view.native
 141                 assert native_view isa UIView
 142                 native.add_subview native_view
 143
 144                 fill_whole_window_with(native_view, native)
 145         end
 146
 147         private fun fill_whole_window_with(native: UIView, window: UIWindow)
 148         in "ObjC" `{
 149                 // Hard coded borders including the top bar
 150                 // FIXME this may cause problems with retina devices
 151                 [window addConstraints:[NSLayoutConstraint
 152                         constraintsWithVisualFormat: @"V:|-24-[view]-8-|"
 153                         options: 0 metrics: nil views: @{@"view": native}]];
 154                 [window addConstraints:[NSLayoutConstraint
 155                         constraintsWithVisualFormat: @"H:|-8-[view]-8-|"
 156                         options: 0 metrics: nil views: @{@"view": native}]];
 157
 158                 // Set the required root view controller
 159                 window.rootViewController = [[UIViewController alloc]initWithNibName:nil bundle:nil];
 160                 window.rootViewController.view = native;
 161         `}
 162 end
 163
 164 redef class Layout
 165
 166         redef type NATIVE: UIStackView
 167         redef var native = new UIStackView
 168
 169         init
 170         do
 171                 native.alignment = new UIStackViewAlignment.fill
 172                 native.distribution = new UIStackViewDistribution.fill_equally
 173                 native.translates_autoresizing_mask_into_constraits = false
 174
 175                 # TODO make customizable
 176                 native.spacing = 4.0
 177         end
 178
 179         redef fun add(view)
 180         do
 181                 super
 182
 183                 var native_view = view.native
 184                 assert native_view isa UIView
 185                 self.native.add_arranged_subview native_view
 186         end
 187 end
 188
 189 redef class HorizontalLayout
 190         redef init do native.axis = new UILayoutConstraintAxis.horizontal
 191 end
 192
 193 redef class VerticalLayout
 194         redef init do native.axis = new UILayoutConstraintAxis.vertical
 195 end
 196
 197 redef class Label
 198
 199         redef type NATIVE: UILabel
 200         redef var native = new UILabel
 201
 202         redef fun text=(text) do native.text = (text or else "").to_nsstring
 203         redef fun text do return native.text.to_s
 204 end
 205
 206 # On iOS, check boxes are a layout composed of a label and an `UISwitch`
 207 redef class CheckBox
 208
 209         redef type NATIVE: UIStackView
 210         redef fun native do return layout.native
 211
 212         # Root layout implementing this check box
 213         var layout = new HorizontalLayout(parent=self.parent)
 214
 215         # Label with the text
 216         var lbl = new Label(parent=layout)
 217
 218         # `UISwitch` acting as the real check box
 219         var ui_switch: UISwitch is noautoinit
 220
 221         init do
 222                 # Tweak the layout so it is centered
 223                 layout.native.distribution = new UIStackViewDistribution.fill_proportionally
 224                 layout.native.alignment = new UIStackViewAlignment.center
 225                 layout.native.layout_margins_relative_arrangement = true
 226
 227                 var s = new UISwitch
 228                 native.add_arranged_subview s
 229                 ui_switch = s
 230         end
 231
 232         redef fun text=(text) do lbl.text = text
 233         redef fun text do return lbl.text
 234
 235         redef fun is_checked do return ui_switch.on
 236         redef fun is_checked=(value) do ui_switch.set_on_animated(value, true)
 237 end
 238
 239 redef class TextInput
 240
 241         redef type NATIVE: UITextField
 242         redef var native = new UITextField
 243
 244         redef fun text=(text) do native.text = (text or else "").to_nsstring
 245         redef fun text do return native.text.to_s
 246
 247         redef fun is_password=(value)
 248         do
 249                 native.secure_text_entry = value or else false
 250                 super
 251         end
 252 end
 253
 254 redef class Button
 255
 256         redef type NATIVE: UIButton
 257         redef var native = new UIButton(new UIButtonType.system)
 258
 259         init do native.set_callback self
 260
 261         redef fun text=(text) do if text != null then native.title = text.to_nsstring
 262         redef fun text do return native.current_title.to_s
 263
 264         private fun on_click do notify_observers new ButtonPressEvent(self)
 265
 266         redef fun enabled=(enabled) do native.enabled = enabled or else true
 267         redef fun enabled do return native.enabled
 268 end
 269
 270 redef class UIButton
 271         # Register callbacks on this button to be relayed to `sender`
 272         private fun set_callback(sender: Button)
 273         import Button.on_click in "ObjC" `{
 274
 275                 NitCallbackReference *ncr = [[NitCallbackReference alloc] init];
 276                 ncr.nit_button = sender;
 277
 278                 // Pin the objects in both Objective-C and Nit GC
 279                 Button_incr_ref(sender);
 280                 ncr = (__bridge NitCallbackReference*)CFBridgingRetain(ncr);
 281
 282                 [self addTarget:ncr action:@selector(nitOnEvent:)
 283                         forControlEvents:UIControlEventTouchUpInside];
 284         `}
 285 end
 286
 287 redef class ListLayout
 288
 289         redef type NATIVE: UITableView
 290         redef var native = new UITableView(new UITableViewStyle.plain)
 291
 292         init
 293         do
 294                 native.autoresizing_mask
 295                 native.assign_delegate_and_data_source self
 296         end
 297
 298         redef fun add(item)
 299         do
 300                 # Adding a view to a UITableView is a bit tricky.
 301                 #
 302                 # Items are added to the Objective-C view only by callbacks.
 303                 # We must store the sub views in local lists while waiting
 304                 # for the callbacks.
 305                 #
 306                 # As usual, we keep the Nity object in `items`.
 307                 # But we also keep their native counterparts in a list of
 308                 # the `UITableViewAndDataSource` set as `native.delegate`.
 309                 # Otherwise the native views could be freed by the Objective-C GC.
 310
 311                 # TODO use an adapter for the app.nit ListLayout closer to what exists
 312                 # on both iOS and Android, to support large data sets.
 313
 314                 if item isa View then
 315                         add_view_to_native_list(native, item.native)
 316                 end
 317
 318                 super
 319
 320                 # Force redraw and trigger callbacks
 321                 native.reload_data
 322         end
 323
 324         private fun add_view_to_native_list(native: UITableView, item: UIView) in "ObjC" `{
 325                 [((UITableViewAndDataSource*)native.delegate).views addObject:item];
 326         `}
 327
 328         private fun get_view_from_native_list(native: UITableView, index: Int): UIView in "ObjC" `{
 329                 return [((UITableViewAndDataSource*)native.delegate).views objectAtIndex:index];
 330         `}
 331
 332         # Number of sections in this view
 333         #
 334         # By default, we assume that all `items` are in a single section,
 335         # so there is only one section.
 336         #
 337         # iOS callback: `numberOfSectionsInTableView`
 338         protected fun number_of_sections_in_table_view(view: UITableView): Int
 339         do return 1
 340
 341         # Number of entries in `section`
 342         #
 343         # By default, we assume that all `items` are in a single section,
 344         # so no matter the section, this returns `items.length`.
 345         #
 346         # iOS callback: `numberOfRowsInSection`
 347         protected fun number_of_rows_in_section(view: UITableView, section: Int): Int
 348         do return items.length
 349
 350         # Title for `section`, return `new NSString.nil` for no title
 351         #
 352         # By default, this returns no title.
 353         #
 354         # iOS callback: `titleForHeaderInSection`
 355         protected fun title_for_header_in_section(view: UITableView, section: Int): NSString
 356         do return new NSString.nil
 357
 358         # Return a `UITableViewCell` for the item at `index_path`
 359         #
 360         # By default, we assume that all `items` are in a single section.
 361         # So no matter the depth of the `index_path`, this returns a cell with
 362         # the view at index part of `index_path`.
 363         #
 364         # iOS callback: `cellForRowAtIndexPath`
 365         protected fun cell_for_row_at_index_path(table_view: UITableView, index_path: NSIndexPath): UITableViewCell
 366         do
 367                 var reuse_id = "NitCell".to_nsstring
 368                 var cell = new UITableViewCell(reuse_id)
 369
 370                 # TODO if there is performance issues, reuse cells with
 371                 # the following code, but clear the cell before use.
 372
 373                 #var cell = table_view.dequeue_reusable_cell_with_identifier(reuse_id)
 374                 #if cell.address_is_null then cell = new UITableViewCell(reuse_id)
 375
 376                 var index = index_path.index_at_position(1)
 377                 var view_native = get_view_from_native_list(table_view, index)
 378                 var cv = cell.content_view
 379                 cv.add_subview view_native
 380
 381                 return cell
 382         end
 383 end
 384
 385 redef class UITableView
 386
 387         # Assign `list_view` as `delegate` and `dataSource`, and pin all references in both GCs
 388         private fun assign_delegate_and_data_source(list_view: ListLayout)
 389         import ListLayout.number_of_sections_in_table_view,
 390                ListLayout.number_of_rows_in_section,
 391                ListLayout.title_for_header_in_section,
 392                ListLayout.cell_for_row_at_index_path in "ObjC" `{
 393
 394                 UITableViewAndDataSource *objc_delegate = [[UITableViewAndDataSource alloc] init];
 395                 objc_delegate = (__bridge UITableViewAndDataSource*)CFBridgingRetain(objc_delegate);
 396
 397                 objc_delegate.nit_list_layout = list_view;
 398                 ListLayout_incr_ref(list_view);
 399
 400                 // Set our
 401                 self.delegate = objc_delegate;
 402                 self.dataSource = objc_delegate;
 403         `}
 404 end