This video demonstrates the new user interface and the app tiles in Windows 8. It also shows a few basics of how to make life easier using Windows 8 and power options. Windows installed by the default options will choose the Balanced power plan which will not give you the best output from your processor. Selecting a High performance powerplan in the background will also allow your processor to use more power and be more efficient.
techytube
For more videos on technology, visit http://www.Techytube.com
This video demonstrates the new user interface and the app tiles in Windows 8. It also shows a few basics of how to make life easier using Windows 8 and power options. Windows installed by the default options will choose the Balanced power plan which will not give you the best output from your processor. Selecting a High performance powerplan in the background will also allow your processor to use more power and be more efficient.
This video demonstrates the new user interface and the app tiles in Windows 8. It also shows a few basics of how to make life easier using Windows 8 and power options. Windows installed by the default options will choose the Balanced power plan which will not give you the best output from your processor. Selecting a High performance powerplan in the background will also allow your processor to use more power and be more efficient.
updated 12 years ago
This video demonstrates the new user interface and the app tiles in Windows 8. It also shows a few basics of how to make life easier using Windows 8 and power options. Windows installed by the default options will choose the Balanced power plan which will not give you the best output from your processor. Selecting a High performance powerplan in the background will also allow your processor to use more power and be more efficient.
- High overview of how a cluster works
- Network and storage configuration using iSCSI and Hyper-V
- Create a new cluster
- Create a new file server that is clustered
http://www.wireshark.org
- How to add the DFS Replication role using PowerShell remote commands to 4 target file servers
- Use DFS Management console to create a new replication group
- Initiate immediate replication between two partner file servers
- Access the DFS replicated folder from client systems
To get a copy of the script used in this video please download it from the following location (Techytube's GitHub Repository):
http://tinyurl.com/y8d53387
- How to create a domain based DFS namespace
- Add namespace servers to the DFS root
- How to access the root and links underneath
- Add folder targets to a DFS root and make them accessible to your users
By techytube@techytube, for more from this author visit:
http://www.techytube.com/author/techytube
This video shows how you can create a virtual disk on a server with ample storage and attach it to an iSCSI initiator.
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Now that we have loaded some Feed data, we need to customize our page with some data binding.
To avoid having to worry about managing the title for each blog, we will instead data bind the title text directly to the title of the feed.
This will let us offer a consistent user experience, with a minimum of scaffolding in our code.
In this video, I will show you how to bind a data item to a grid element, and change the column span of a grid.
References
XAML Blog Reader -- http://msdn.microsoft.com/en-us/library/windows/apps/br211380.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Now that the UI for our main application page is working, we need to add navigation to other related pages.
While we have looked at adding a navigation bar previously, we can also navigate to a new page by simply adding code to the ItemClick event handler.
Additionally, we can pass in parameters to identify the previous page, and give the target page whatever data it needs.
In this video, I will show you how to enable the ItemClick event, and add code to the ItemClick event handler.
References
XAML Blog Reader -- http://msdn.microsoft.com/en-us/library/windows/apps/br211380.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
When we finish navigating to the SplitPage, we need to load some state information from our blog feeds.
We will do this through the familiar LoadState method, and using some simple parameter casting we will populate the title of the different blogs.
In this video, I will show you how to use a navigation parameter of type Object to load state in a new page.
References
XAML Blog Reader -- http://msdn.microsoft.com/en-us/library/windows/apps/br211380.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
By default, Visual Studio creates new projects with a title of 'My Application'.
This is usually acceptable for a hello world application, but we will want to change this to match the intent of our application, being a Blog Reader.
We could change this resource in many ways, but we are simply going to edit the Text property as a static resource.
In this video, I will show you how to edit a static resource, namely the Text property of a TextBlock representing our page title.
References
XAML Blog Reader -- http://msdn.microsoft.com/en-us/library/windows/apps/br211380.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
We've created a class that will handle the blog data feeds we are interested in, but now we have to incorporate that class into our program.
Using App.xaml, we can insert a named instnace of our feed data, and then later manipulate that instance to retrieve data feeds.
For those familiar with XML, XAML allows for easily defining a resource, and inserting it at an appropriate point in the schema.
In this video, I will show you how to add a resource to an application using XAML.
References
XAML Blog Reader - http://msdn.microsoft.com/en-us/library/windows/apps/br211380.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Developers familiar with Visual Studio are aware that it is possible to change the startup project via a context menu.
Similarly, when the application starts, it will load the page defined in the OnLaunched method. In order to change which page is launched, the type of the page passed in just needs to match a type within the current project which derives from LayoutAwarePage.
In this video, I will show you how to change the start page for a XAML application through the code-behind file.
References
XAML Blog Reader - http://msdn.microsoft.com/en-us/library/windows/apps/br211380.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Now that we've added our resource for the feed data, we need to override the OnLaunched method in App.xaml.
Since our application also needs to check for an internet connection, we will make use of the NetworkInformation class.
This class presents a standardized way to check for an active internet connection rather than an arbitrary DNS query, or other methods of checking for connection.
OnLaunched is called when the application is launched, and it is in this method that we'll perform our internet check, as well as start pulling down feeds.
In this video, I will show you how to override the OnLaunched method with application specific logic, and how to use the NetworkInformation class.
References
XAML Blog Reader - http://msdn.microsoft.com/en-us/library/windows/apps/br211380.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Adding UI pages is a fundamental part of creating any interactive application, and can sometimes be quite time consuming.
Luckily, there are several templates to choose from which can speed up the process, and reduce development time by enabling rapid deployment of pre-defined templates.
In this video, I will show you how to add multiple pages to a XAML application.
References
XAML Blog Reader - http://msdn.microsoft.com/en-us/library/windows/apps/br211380.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Next we're going to hook up the UI for our main application page through the DefaultViewModel collection.
A page of type 'Items' has a default View Model defined, and it is possible to hook up to a data source with only a few lines of code.
Once done, the page will render the items in the default template format. Of course,customization will likely take place from the default settings.
In this video, I will show you how to bind our data feeds to the DefaultViewModel["Items"] element of our ItemsPage.
References
XAML Blog Reader - http://msdn.microsoft.com/en-us/library/windows/apps/br211380.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
As we enter the final portion of our XAML Windows 8 series, we will start creating a meaningful application beyond our PhotoViewer, a Blog Reader.
Windows Team blogs will be chosen, but any blog that syndicates over RSS is feasible to use in our application.
In this video, I will show you how to create a new project for the Blog Reader and add a data class.
References
XAML Blog Reader - http://msdn.microsoft.com/en-us/library/windows/apps/br211380.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
After creating our project and copying some code from our tutorial, we will now examine that code.
The SyndicationClient makes pulling down feeds next to trivial, however to make a responsive application asynchronous programming is the best approach.
The await keyword takes care of a lot of work behind the scenes such as creating callbacks, and allows updating UI elements in the same piece of code as an asynchronous call is made, without the need to invoke any external dispatchers.
In this video, I will discuss the sample code and the asynchronous approach.
References
XAML Blog Reader -- http://msdn.microsoft.com/en-us/library/windows/apps/br211380.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
In our last video, we used the picture selected via our file picker to populate properties to text blocks.
Now, we want to save the state of our new page, so that the picture selected will persist across application launches.
At first glance it might seem as easy as just preserving the file path, but we will need to consider permissions to that image first.
When a file picker is launched, file access permissions are given to the application to any file the user selects (implicitly). To maintain these permissions, we will need to register the file as a 'Most Recently Used' file, and use the token returned from that operation for future access.
In this video, I will show you how to save the state of a file picker.
References
XAML File Pickers -- http://msdn.microsoft.com/en-us/library/windows/apps/jj655411.aspx
By pavel@techytube, for more from this author visit:
http://www.techytube.com/author/pavel
View Controller call a series of methods before loading all the views and being ready for users to interact with them. The "viewDidLoad" method is invoked first. Inside it we should do any additional setup after loading the view, typically from a nib.
There are other 4 commonly used methods that any iOS developer should know about:
- (void)viewWillAppear:(BOOL)animated
- (void)viewDidAppear:(BOOL)animated
- (void)viewWillDisappear:(BOOL)animated
- (void)viewDidDisappear:(BOOL)animated
"viewWillAppear" is called when the view is about to made visible. Default does nothing.
"viewDidAppear" is called when the view has been fully transitioned onto the screen. Default does nothing.
"viewWillDisappear" is called when the view is dismissed, covered or otherwise hidden. Default does nothing.
"viewDidDisappear" is called after the view was dismissed, covered or otherwise hidden. Default does nothing.
There are situations when we need some specific things to be done, for example to save some data if the user quits the app, and these and some other ones are the places where she to insert that logic in our projects.
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Previously, we explained how to save the currently selected state of a file picker in a XAML application.
As before, however, we need to load the saved state to have the changed reflected in the relaunch of our application.
Now, we will add logic to load the state at program launch, and demonstrate the full lifecycle of data within the application.
In this video, I will show you how to load state from a file picker.
XAML File Pickers -- http://msdn.microsoft.com/en-us/library/windows/apps/jj655411.aspx
By pavel@techytube, for more from this author visit:
http://www.techytube.com/author/pavel
The NavBar or the navigation bar is the top side view that appears by default over our main view if we have a navigation controller presenting the corresponding view controller.
Its dimensions for iPhone and iPod touch are 320 x 44, so if we want to set custom background images for that, we need 2 images: one normal of 320 x 44 pixels, and the other one for Retina Display, of 640 x 88 pixels.
iOS provides us 4 default options for customising the NavBar, and we do that by writing the following line of code:
self.navigationController.navigationBar.barStyle = UIBarStyleDefault;
The "barStyle" property can be set to one of 4 values, which are:
UIBarStyleDefault,
UIBarStyleBlack,
UIBarStyleBlackOpaque,
UIBarStyleBlackTranslucent.
Starting with iOS 5, it is very easy to set a background image for the NavBar in this way:
UIImage *navBarImage = [UIImage imageNamed:@"nav-bar-image"];
[[UINavigationBar appearance] setBackgroundImage:navBarImage forBarMetrics:UIBarMetricsDefault];
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Data binding is an essential concept to software development, and one that is luckily made near-trivial by Visual Studio.
In a one-way binding, data is populated in one direction, to the end UI control. In this system, changing a value in the control does not reflect in the data source.
In a two-way binding scenario, data can flow back from the control to the data source. This is useful for an 'edit' role, versus a 'label' role which would more appropriately make use of one-way binding.
Data binding was made popular in WinForms (.NET 2.0), and Visual Studio 2012 makes it intuitive. Through multiple methods, such as Binding.Source and DataContext switching, a control can be bound to a source in just a few clicks.
In this video, I will show you how to bind a TextBlock to the DisplayName property in a file chosen from a FilePicker.
References
XAML File Pickers - http://msdn.microsoft.com/en-us/library/windows/apps/jj655411.aspx
By pavel@techytube, for more from this author visit:
http://www.techytube.com/author/pavel
The UINavigationController class implements a specialized view controller that manages the navigation of hierarchical content. This class is not intended for subclassing. Instead, you use instances of it as-is in situations where you want your application's user interface to reflect the hierarchical nature of your content. This navigation interface makes it possible to present your data efficiently and also makes it easier for the user to navigate that content.
To create a navigation controller programmatically, you have to write the following code:
UINavigationController *navController = [[UINavigationController alloc] initWithRootViewController:self.viewController];
Usually that is done in the "AppDelegate.m" file, but it can be done in any file you need.
If you do that in the "AppDelegate.m" file than you should replace the line:
self.window.rootViewController = self.viewController;
with the following line:
self.window.rootViewController = navController;
and it is perfectly ok because UINavigationController is a subclass of UIViewController.
If you run the program, you may notice a blue navigation bar appears on the top. You can customise that if you want, or you can hide it using any of the 2 lines below:
navController.navigationBarHidden = YES;
navController.navigationBar.hidden = YES;
To set a title in the NavBar, you should write in the "viewDidLoad" method of the ViewController class that is currently displayed by the Navigator object, any of the 2 lines below:
self.navigationItem.title = @"Title";
self.title = @"Title";
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Previously we have used boilerplate code, with some modification, to add a file picker workflow to our application.
Now, we need to review that code to understand each step, and any modifications which may be needed for different uses for the workflow.
We will also leverage asynchronous programming, to ensure this operation does not block any other elements of the application.
In this video, I will review the code we previously used for the file picker workflow.
References
XAML File Pickers -- http://msdn.microsoft.com/en-us/library/windows/apps/jj655411.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
In the start of the new section of the XAML tutorial, we'll be looking at file access.
File access is an important part of any application, and Windows 8 introduces some new rich workflows to enhance the experience.
Tablets add some new considerations to file access, in that the file picker UI will not work if the application is in Snapped view.
In this video, I will show you how to add a file picker interaction to an event handler of a button.
References
XAML File Pickers - http://msdn.microsoft.com/en-us/library/windows/apps/jj655411.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Visual Studio 2012 offers a powerful new feature for application development and debugging, the 'Device' pane.
The device pane allows the designer to reconfigure itself to match the four visual states : snapped, filled, full screen horizontal, or full screen vertical.
Developers are now able to test against different states at the click of a button, as well as against different resolutions without any further scaffolding required.
In this video, I will show you how to use the 'Device' pane in Visual Studio 2012.
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Now that we know how to edit different views, we will look at the first view that seems to be in need of editing, the Snapped view.
A snapped-application will display in a small column in the left of the screen, allowing two applications to be used simultaneously. It is likely, however, that a snapped application will have some modifications require to that view.
By keeping the view edits view-specific, we can optimize the user experience for each possible view.
In this video, I will show you how to edit the 'Snapped' view.
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Our last task in this section is to edit the remaining view that needs to be changed, the portrait view.
The portrait view offers more vertical real estate, but less horizontal, and is well suited to displaying documents.
By making a few simple changes, as before, we can ensure that our content is displayed in an appropriate manner.
In this video, I will show you how to edit the 'Portrait' view.
References
XAML Navigation, Layout, Views -- http://msdn.microsoft.com/en-us/library/windows/apps/jj215600.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
We have added the first controls needed for our photo viewer page, and now we need to add the main Image control.
We will not, however just be adding a single control. To give all the functionality desired, we need to place the Image control in a container, the StackPanel.
In this video, I will show you how to add a StackPanel container and child controls.
References
XAML Navigation, Layout, Views -- http://msdn.microsoft.com/en-us/library/windows/apps/jj215600.aspx
By pavel@techytube, for more from this author visit:
http://www.techytube.com/author/pavel
There are some situation when we have to give the users the possibility to enter a date.
He may input some invalid characters over there. Therefore, iOS SDK provides us a special class that enables us to choose a date from many options, and it is named UIDatePicker.
Any object of this class has a special method "date", which by default returns the current date and time in the following format:
YYYY-MM-DD hh:mm:ss +0000
We can format this output as we want, but this is the default one. We may use the UIDatePicker class to give different options to choose either date or time, as you will see in the next lessons, we can customise its appearance.
For more information, you can check the Apple's online Documentation at:
http://developer.apple.com/library/ios/#documentation/uikit/reference/UIDatePicker_Class/Reference/UIDatePicker.html
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Now that we've covered styling the App Bar, it's time to move onto inserting controls in the application workspace itself.
A grid control is likely familiar to anyone who has developed with .NET, but the latest iteration of the control offers interaction familiar to both developers and users of graphical design products.
Using these controls, we can quickly lay out an application, define dimensions, and start inserting our own controls specific to the application logic.
In this video, I will show you how to add and configure a Grid to a Windows 8 XAML application.
References
XAML Navigation, Layout, Views -- http://msdn.microsoft.com/en-us/library/windows/apps/jj215600.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Previously we have added a grid to our Photo Page, and now we will be placing controls in that grid.
When dropping new controls, it's important to realize that their initial configuration may not align with the design in your application. In ours too, we will be resetting some of the main properties to get the control to properly render in our grid.
In this video, I will show you how to add a Button, and a TextBlock to a Grid.
References
XAML Navigation, Layout, Views -- http://msdn.microsoft.com/en-us/library/windows/apps/jj215600.aspx
By pavel@techytube, for more from this author visit:
http://www.techytube.com/author/pavel
The UIPickerView class implements objects, called picker views, that use a spinning-wheel or slot-machine metaphor to show one or more sets of values. Users select values by rotating the wheels so that the desired row of values aligns with a selection indicator.
The UIDatePicker class uses a custom subclass of UIPickerView to display dates and times. To see an example, tap the add ("+") button in the the Alarm pane of the Clock application.
The user interface provided by a picker view consists of components and rows. A component is a wheel, which has a series of items (rows) at indexed locations on the wheel. Each component also has an indexed location (left to right) in a picker view. Each row on a component has content, which is either a string or a view object such as a label (UILabel) or an image (UIImageView).
For more information, you can check the Apple's online Documentation at:
http://developer.apple.com/library/ios/#documentation/uikit/reference/UIPickerView_Class/Reference/UIPickerView.html
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
We have almost added all the controls we will be using, and will now be adding more child controls
StackPanel's are very easy to add controls to, in that they will automatically handle sizing for us.
In this video, I will show you how to add content controls to a StackPanel.
References
XAML Navigation, Layout, Views -- http://msdn.microsoft.com/en-us/library/windows/apps/jj215600.aspx
By pavel@techytube, for more from this author visit:
http://www.techytube.com/author/pavel
A UIDatePicker class allow us to customise the objects of its type. To do that, we have 4 options:
UIDatePickerModeTime
UIDatePickerModeDate
UIDatePickerModeDateAndTime
UIDatePickerModeCountDownTimer
, which represent the values of an Enum type in the iOS SDK. Usually we do that in Xcode Interface Builder, if the date-pickers are created visually as well.
When we interact with the UIDatePicker objects, we can call different event methods. The most common (which also comes as the default option when making the IBAction connection) is:
"- (IBAction)datePickerValueChanged:(id)sender".
If we want to get the value of the selected date and/or time from out picker in one of these methods, we can refer to the IBOutlet object or property if we have one, or we can change the parameter type from "id" to "UIDatePicker *", and then use the sender parameter-object (which is the actual UIDatePicker object).
For more information, you can check the Apple's online Documentation at:
http://developer.apple.com/library/ios/#documentation/uikit/reference/UIDatePicker_Class/Reference/UIDatePicker.html
By pavel@techytube, for more from this author visit:
http://www.techytube.com/author/pavel
The UITableViewDataSource protocol is usually implemented by an ViewController class that mediates the application's data model for a UITableView object. The data source provides the table view object with the information it needs to construct and modify a table view.
As a representative of the data model, the data source supplies minimal information about the table view's appearance. The table-view object's delegate—an object adopting the UITableViewDelegate protocol—provides that information.
In the last video we've discussed about the required methods of the UITableViewDelegate protocol. There are also a couple of optional methods. For example in case of Grouped-Style table-views, we have sections, and each section may have a header and a footer.
To specify how many sections a table view should have, we implement the following method:
- (NSInteger)numberOfSectionsInTableView:(UITableView *)tableView
{
return 2; // 2 should be replaced with the number of sections we need
}
To specify the title of each section in a table view, we implement the following method:
- (NSString *)tableView:(UITableView *)tableView
titleForHeaderInSection:(NSInteger)section
{
NSString *titleOfSection;
switch (section) {
case 0:
titleOfSection = @"First Section";
break;
case 1:
titleOfSection = @"Second Section";
// ... and so on, depending how many sections we must have
default:
titleOfSection = @"No Title";
break;
}
return titleOfSection;
}
For more, please visit Apple's online documentation at:
http://developer.apple.com/library/ios/#documentation/uikit/reference/UITableViewDataSource_Protocol/Reference/Reference.html
By pavel@techytube, for more from this author visit:
http://www.techytube.com/author/pavel
The UITableViewDataSource protocol is usually implemented by an ViewController class that mediates the application's data model for a UITableView object. The data source provides the table view object with the information it needs to construct and modify a table view.
As a representative of the data model, the data source supplies minimal information about the table view's appearance. The table-view object's delegate—an object adopting the UITableViewDelegate protocol—provides that information.
The two required methods of the protocol provide the cells to be displayed by the table-view as well as inform the UITableView, and they should look as below:
- (NSInteger)tableView:(UITableView *)tableView numberOfRowsInSection:(NSInteger)section
{
return 3;
}
- (UITableViewCell *)tableView:(UITableView *)tableView cellForRowAtIndexPath:(NSIndexPath *)indexPath
{
static NSString *CellIdentifier = @"Cell";
UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
if (cell == nil)
{
cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault reuseIdentifier:CellIdentifier];
}
return cell;
}
We can also set the cell's properties, for example:
cell.textLabel.text = [NSString stringWithFormat:@"Cell %d", indexPath.row];
Many methods take NSIndexPath objects as parameters. UITableView declares a category on NSIndexPath that enables you to get the represented row index (row property) and section index (section property), and to construct an index path from a given row index and section index (indexPathForRow:inSection: class method). (The first index in each index path identifies the section and the next identifies the row.)
For more, please visit Apple's online documentation at:
http://developer.apple.com/library/ios/#documentation/uikit/reference/UITableViewDataSource_Protocol/Reference/Reference.html
By pavel@techytube, for more from this author visit:
http://www.techytube.com/author/pavel
The delegate of a UITableView object must adopt the UITableViewDelegate protocol. Optional methods of the protocol allow the delegate to manage selections, configure section headings and footers, help to delete and reorder cells, and perform other actions.
Many methods of UITableViewDelegate take NSIndexPath objects as parameters and return values. UITableView declares a category on NSIndexPath that enables you to get the represented row index (row property) and section index (section property), and to construct an index path from a given row index and section index (indexPathForRow:inSection: method). Because rows are located within their sections, you usually must evaluate the section index number before you can identify the row by its index number.
One very important method is:
- (void)tableView:(UITableView *)tableView didSelectRowAtIndexPath:(NSIndexPath *)indexPath
and it used in Master-Detail applications, where we have a Main/Master view which contains a basic table with general information about the items that we want to display, and when we click on any of the items, it takes us to a Detailed view, which contains all the info about the selected item.
For more, please visit Apple's online documnation at:
http://developer.apple.com/library/ios/#documentation/uikit/reference/UITableViewDelegate_Protocol/Reference/Reference.html
By pavel@techytube, for more from this author visit:
http://www.techytube.com/author/pavel
A cell in a UITableView is an object of UITableViewCell class, and can have one of four styles, which are:
UITableViewCellStyleDefault, UITableViewCellStyleSubtitle, UITableViewCellStyleValue1, and UITableViewCellStyleValue2, and you can use those according to your app's specifications, or you can create your custom cells.
In this video tutorial we will create a custom cell programmatically. For that we have to do most of our work in the "tableView:cellForRowAtIndexPath:" method. First we need a dataSource to populate the cell with info, so declare a private property for that, in the VieController.m file, just after the #import statement:
@interface ViewController ()
@property (nonatomic, retain) NSMutableArray *dataSource;
@end
Then, in the viewDidLoad method allocate and initialise that:
self.dataSource = [NSMutableArray array];
[self.dataSource addObject:[NSArray arrayWithObjects:@"20", @"JUN", @"7:00PM", @"Toyota Center", @"Houston, TX", @"FROM", @"$200", nil]];
[self.dataSource addObject:[NSArray arrayWithObjects:@"6", @"JUL", @"8PM", @"Frank Erwin Center", @"Austin, TX", @"FROM", @"$350", nil]];
In the "tableView:numberOfRowsInSection:" method return self.dataSource.count.
In the "tableView:cellForRowAtIndexPath:" method write:
// Each subview in the cell will be identified by a unique tag
static NSUInteger const kDayLabelTag = 2;
static NSUInteger const kMonthLabelTag = 3;
// ... and so on
static NSString *CellIdentifier = @"Cell";
UITableViewCell *cell = [tableView dequeueReusableCellWithIdentifier:CellIdentifier];
UILabel *dayLabel;
UILabel *monthLabel;
// ... and so on
if (cell == nil)
{
cell = [[UITableViewCell alloc] initWithStyle:UITableViewCellStyleDefault
reuseIdentifier:CellIdentifier];
cell.selectionStyle = UITableViewCellSelectionStyleNone;
// Define the frames for each component of the Cell
CGRect dayFrame = CGRectMake(5, 7, 64, 30);
CGRect monthFrame = CGRectMake(5, 35, 64, 16);
// ... and so on
// Adjust all the controls correspondingly
dayLabel = [[UILabel alloc] initWithFrame:dayFrame];
dayLabel.tag = kDayLabelTag;
dayLabel.font = [UIFont boldSystemFontOfSize:30.0f];
dayLabel.backgroundColor = [UIColor clearColor];
dayLabel.textColor = [UIColor darkGrayColor];
dayLabel.textAlignment = NSTextAlignmentCenter;
monthLabel = [[UILabel alloc] initWithFrame:monthFrame];
monthLabel.tag = kMonthLabelTag;
monthLabel.font = [UIFont boldSystemFontOfSize:16.0f];
monthLabel.backgroundColor = [UIColor clearColor];
monthLabel.textColor = [UIColor colorWithRed:0.0f/255.0f
green:140.0f/255.0f
blue:220.0f/255.0f
alpha:1.0f];
monthLabel.textAlignment = NSTextAlignmentCenter;
// ... and so on
// Add all created components to the new Cell
[cell.contentView addSubview:dayLabel];
[cell.contentView addSubview:monthLabel];
// ... and so on
}
else
{
// A reusable cell was available, so we just need to get
// a reference to the subviews using their tags
dayLabel = (UILabel *) [cell.contentView viewWithTag:kDayLabelTag];
monthLabel = (UILabel *) [cell.contentView viewWithTag:kMonthLabelTag];
}
NSArray *cellInfoArray = [self.dataSource objectAtIndex:indexPath.row];
dayLabel.text = [cellInfoArray objectAtIndex:0];
monthLabel.text = [cellInfoArray objectAtIndex:1];
return cell;
By pavel@techytube, for more from this author visit:
http://www.techytube.com/author/pavel
A cell in a UITableView is an object of UITableViewCell class, and can have one of four styles, which are:
UITableViewCellStyleDefault, UITableViewCellStyleSubtitle, UITableViewCellStyleValue1, and UITableViewCellStyleValue2, and you can use those according to your app's specifications, or you can create your custom cells, which we will discuss later.
All the cell styles (except UITableViewCellStyleDefault) allow us to specify a textLabel, and a detailTextLabel. We can also have an image on the left.
For the right side, we can specify different accessory types, which are:
UITableViewCellAccessoryNone, UITableViewCellAccessoryDisclosureIndicator, UITableViewCellAccessoryDetailDisclosureButton, and UITableViewCellAccessoryCheckmark. Each accessory type has its own meaning, and you have to check that in the Human Interface Guidelines provided by Apple. In case you use them for different meaning your app may get rejected.
For more, please visit Apple's online documentation at:
http://developer.apple.com/library/ios/#documentation/uikit/reference/UITableViewCell_Class/Reference/Reference.html
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Visual Studio provides many tools that we can make use of for designing applications, but having a solid foundation of knowledge about how layouts work is critical.
Fluid layout lets developers focus on application logic rather than layout and alignment, but there are cases where a static layout is desired. Luckily, Visual Studio allows us to integrate both approaches.
In this video, I will go over static and fluid layouts, and the tools available in the Visual Studio designer.
References
XAML Navigation, Layout, Views -- http://msdn.microsoft.com/en-us/library/windows/apps/jj215600.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
We have now added a 'photo page' to our XAML application.
Before we can make use of this new page, however, we have to provide a mechanism to navigate from our main page to the photo page.
A benefit to using the LayoutAwarePage type is that backwards navigation is automatically taken care of.
In this video, I will show you how to add navigation between 2 pages.
References
XAML Navigation, Layout, Views -- http://msdn.microsoft.com/en-us/library/windows/apps/jj215600.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Last time, we looked at how to tailor the layout of Visual Studio to best fit the project we are working on.
Now, we will continue with that concept, and change the layout of our application with regards to navigation.
A navigation button will generally not reside in the middle of your application, as it currently does with our Photo Reader project. We will need to move that navigation button to somewhere more appropriate.
In this video, I will show you how to put a control in the Top App Bar and use that control for navigation.
References
XAML Navigation, Layout, Views -- http://msdn.microsoft.com/en-us/library/windows/apps/jj215600.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
Last time, we placed a navigation control that was previously on the front page of our application into the app bar.
We now want to style it to fit in with the rest of the application and the app bar theme in general.
A default style for picture navigation buttons resides in StandardStyles.xaml, and we will enable that style and apply it to our navigation button.
In this video, I will show you how to style the 'Photo' navigation button.
References
XAML Navigation, Layout, Views -- http://msdn.microsoft.com/en-us/library/windows/apps/jj215600.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
In our last video, we went over the basics of using Visual Studio design tools, and layout concepts.
Now, we will explore the Visual Studio environment, and go over how to set up your workspace, as well as how to change a control from the default static layout type to a fluid layout.
In this video, I will show you how to change the layout of the Visual Studio workspace, and how to reset a control's properties.
References
XAML Navigation, Layout, Views -- http://msdn.microsoft.com/en-us/library/windows/apps/jj215600.aspx
By techytube@techytube, for more from this author visit:
http://www.techytube.com/author/techytube
Windows 8 Store apps can be distributed to the general public through the Windows Store. For Line of Business applications that you may be developing in-house, an alternative distribution method exists. This requires a few steps:
1. Create an APPX package by using the Store menu in Visual Studio.
2. You then have to Validate the app. This will be presented to you when you finish creating the APPX package.
3. Once validation is passed, Visual Studio will create a PowerShell script that can be used to do the App installation.
For end-user systems to allow this installation to take place a few things are required. They need to be running the Enterprise version of the Windows 8 operating system and a Group Policy setting must be in place.
Computer Configuration\Administrative Templates\Windows Components\App Package Deployment
The setting that you need to enable here is:
Allow all trusted apps to install setting
Doing the above or setting the below registry key on all systems that will receive the app is:
HKEY_LOCAL_MACHINE\Software\Policies\Microsoft\Windows\Appx\AllowAllTrustedApps = 1
Once these are in place, the installation should take place without any issues.
Source:
http://technet.microsoft.com/en-us/library/hh852635.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
We have successfully saved important pieces of data relating to our application's state, and now we need to learn how to restore that data.
You will need to restore application data always, but not so with session state. You will need to restore session state only if your application was not terminated with the close gesture, a log off, or alt+f4.
In this video, I will show you the framework we will use to restore application state.
References
XAML Application Lifecycle -- http://msdn.microsoft.com/en-us/library/windows/apps/hh986968.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
We have looked at the framework for restoring state, and now we will implement it in our sample application that we have developed thus far.
Implementing restore logic is most complex in relation to how your particular application functions, but it is easy to go through if we keep the actual application to a demo / hello world level of complexity.
In this video, I will show you how to fully implement restoring the state of an application.
References
XAML Application Lifecycle -- http://msdn.microsoft.com/en-us/library/windows/apps/hh986968.aspx
By mzmuda@techytube, for more from this author visit:
http://www.techytube.com/author/mzmuda
We have now fully implemented restoring application state, but we still need to test and verify that the application is acting as we expect it to.
The new lifecycle in Windows 8 introduces a problem in that we need to be able to see what the application does when transitioning to different states, standard debugging will only allow us to test full termination of the application, and not just a suspend action.
In this video, I will show you how to simulate a suspend operation within the Visual Studio debugger.
References
XAML Application Lifecycle -- http://msdn.microsoft.com/en-us/library/windows/apps/hh986968.aspx