Quantcast
Channel: Infragistics Community
Viewing all 2363 articles
Browse latest View live

The Office 365 API vs. SharePlus for Building Mobile SharePoint Solutions

0
0

An API is a set of protocols with which a developer can interface with a given system or platform. Late last year Microsoft released the long awaited APIs for Office 365, finally giving developers a standard way to customize the popular collaboration platform. See here for a good overview from the MSDN site on the various ways you can now develop for the Office 365 platform.

For example, it is possible to write an HTML5 and JavaScript based website that reads data from Office 365 and displays it to users. Or you can build a Windows App which pulls data from a SharePoint Tasks list stored inside SharePoint Online.

But, if we focus on mobile, should you take that much time to create a mobile app from scratch for SharePoint 2013 users? What if you can easily develop personalized enterprise-wide solutions for both Android and iOS platforms right now? And even make them available for SharePoint 2007, 2010, 2013 and Office 365 users. With SharePlus you can develop enterprise apps using your HTML5 and JavaScript skills, saving time and taking advantage of a huge range of existing, tested features for both iOS and Android mobile platforms.

In this post, we’ll look at five facts that shed some light on the similarities and differences between both platforms.

1. FOCUS ON PARTNER ENGAGEMENT

Microsoft is actively encouraging developers to think of Office 365 as a platform and to integrate its data and services into applications for various platforms. The recently relaunched Office Dev Center is a testament to this. SharePlus is also helping developers of SharePoint and Office 365-based mobility applications go to market faster with Infragistics’ Partner Program.

2. BUILDING NATIVE INTRANET APPS FOR MOBILE DEVICES

While Office 365 has a good mobile Web view, accessing over the web isn’t the best approach for everyone. By creating a mobile app, specific for the company's own Office 365 Intranet, users can access a totally bespoke version of the Intranet on the move. Various Microsoft and third party apps exist, but most of them cannot always be easily modified and branded. SharePlus is one of the exceptions with its unique user interface possibilities. Although tailoring the UI to the user’s needs takes time, for large scale deployments and systems, it could pay real dividends.

3. EASE OF CREATING CUSTOMIZED MOBILE EXPERIENCES

Both the Office 365 and SharePlus platforms empower you to create custom solutions that access and interact with your customer’s data. The new Office 365 APIs can be used to build solutions across all mobile, web, and desktop environments for SharePoint 2013 and Office 365. SharePlus was designed for mobilizing SharePoint and Office 365, yet it can easily meet any needs for a multi-purpose solution that ensures a consistent user experience across all mobile environments. Building a custom mobile SharePoint solution is much faster with SharePlus as a basis, because you have all necessary SharePoint functionalities already working – data access, on-the-go collaboration, built-in security features, data synchronization and offline access, an easy-to-use JavaScript API, and ReportPlus BI dashboards. In addition, SharePlus supports SharePoint 2007, 2010, 2013 and Office 365.

4. OFFICE 365 AND OFFLINE CAPABILITIES

Office 365 has one obvious drawback. Like most cloud software, it requires a working Internet connection to display content. So, users on the move, far from a network connection, or in any other way offline, have limited options to stay productive. A solution to this problem would be to build an app that synchronizes certain data while connected, and provides an offline mode while disconnected. SharePlus already has you covered in terms of offline Office 365 capabilities on mobile devices.

5. CROSS-PLATFORM CONSISTENCY, PERSONALIZATION AND BYOD

When considering to build a mobile SharePoint solution, it’s not about choosing one or the other mobile platform. Employees are increasingly using their personal mobile devices for company goals on the go, which has brought up the BYOD (Bring Your Own Device) trend to new heights. SharePlus is specialized in mobile environments (iOS and Android) while the Office 365 API targets web-based environments primarily. You could potentially create a Chrome extension to enrich Office 365 content, using the API - in this way people browsing the desktop web could also access company or employee specific data from Office 365. Based on user account data, SharePlus provides employees with a seamless SharePoint experience across devices. For example, you can start working on a document on your desktop computer, then continue editing it on your iPad while offline on the road, and in the end sync it with your company SharePoint whenever you have connectivity again. You could also share the file and collaborate on it with a colleague, who is using an Android device – the user experience when handling the document remains the same across platforms.

A GLIMPSE INTO THE FUTURE

True mobile enablement of employees is not simply about giving them mobile access to enterprise portals, but about providing them with an optimized mobile experience on mobile devices. The vastness of the SharePoint platform calls for a mobile-first approach as opposed to building web-based mobile applications. Using the SharePlus platform, you can easily create native mobile SharePoint solutions with much less effort than if you built everything from scratch. The new Office 365 APIs could also be used in conjunction with SharePlus APIs in order to cover both native and mobile web environments. As we touched on earlier, Microsoft is putting a lot of effort in documentation and guidelines to help the developer community. So be sure to check out the Office Dev Center and our mobile SharePoint and Business Intelligence solution, and get started!


Developer News - What's IN with the Infragistics Community? (4/13-4/19)

0
0

I've been told many times that the best way to avoid making costly mistakes is to learn from those who have come before. Not one, but two of this week's highest rated articles focus on different types of mistakes you can make when developing your products. Why not check them out and save yourself from making the same mistakes these authors did?

5. Skipping Functional Requirements is a Costly Mistake (SogetiLabs)

4. Visual Studio Time Saver -- Faster HTML Coding (CDN News)

3. What was the First Computer Programming Language? (Computer Hope)

2. ASP.NET Web API: Understanding OWIN/Katana Authentication (CodeProject)

1. 10 Ways to Ruin Your Product (The Product Club)

Too Big Data: Coping with Overplotting

0
0

Scatter plots are a wonderful way of showing (apparent) relationships in bivariate data. Patterns and clusters that you wouldn't see in a huge block of data in a table can become instantly visible on a page or screen. With all the hype around Big Data in recent years it's easy to assume that having more data is always an advantage. But as we add more and more data points to a scatter plot we can start to lose these patterns and clusters. This problem, a result of overplotting, is demonstrated in the animation below.

The data in the animation above is randomly generated from a pair of simple bivariate distributions. The distinction between the two distributions becomes less and less clear as we add more and more data. So what can we do about overplotting?

One simple option is to make the data points smaller. (Note this is a poor "solution" if many data points share exactly the same values.) We can also make them semi-transparent. And we can combine these two options:

These refinements certainly help when we have ten thousand data points. However, by the time we've reached a million points the two distributions have seemingly merged in to one again. Making points smaller and more transparent might help things; nevertheless, at some point we may have to consider a change of visualization. We'll get on to that later. But first let's try to supplement our visualization with some extra information. Specifically let's visualize the marginal distributions. We have several options. There's far too much data for a rug plot, but we can bin the data and show histograms. Or we can use a smoother option - a kernel density plot. Finally, we could use the empirical cumulative distribution. This last option avoids any binning or smoothing but the results are probably less intuitive. I'll go with the kernel density option here, but you might prefer a histogram. The animated gif below is the same as the gif above but with the smoothed marginal distributions added. I've left scales off to avoid clutter and because we're only really interested in rough judgements of relative height.

Adding marginal distributions, particularly the distribution of Variable 2, helps clarify that two different distributions are present in the bivariate data. The twin-peaked nature of Variable 2 is evident whether there are a thousand data points or a million. The relative sizes of the two components is also clear. By contrast, the marginal distribution of Variable 1 only has a single peak, despite coming from two distinct distributions. This should make it clear that adding marginal distributions is by no means a universal solution to overplotting in scatter plots. To reinforce this point, the animation below shows a completely different set of (generated) data points in a scatter plot with marginal distributions. The data again comes from a random sample of two different 2D distributions, but both marginal distributions of the complete dataset fail to highlight this separation. As previously, when the number of data points is large the distinction between the two clusters can't be seen from the scatter plot either.

Returning to point size and opacity, what do we get if we make the data points very small and almost completely transparent?

We can now clearly distinguish two clusters in each dataset. It's difficult to make out any fine detail though.

Since we've lost that fine detail anyway, it seems apt to question whether we really want to draw a million data points. It can be tediously slow and impossible in certain contexts. 2D histograms are an alternative. By binning data we can reduce the number of points to plot and, if we pick an appropriate color scale, pick out some of the features that were lost in the clutter of the scatter plot. After some experimenting I picked a color scale that ran from black through green to white at the high end. Note, this is (almost) the reverse of the effect created by overplotting in the scatter plots above.

In both 2D histograms we can clearly see the two different clusters representing the two distributions from which the data is drawn. In the first case we can also see that there are more counts from the upper-left cluster than the bottom-right cluster, a detail that is lost in the scatter plot with a million data points (but more obvious from the marginal distributions). Conversely, in the case of the second dataset we can see that the "heights" of the two clusters are roughly comparable.

3D charts are overused, but here (see below) I think they actually work quite well in terms of providing a broad picture of where the data is and isn't concentrated. Feature occlusion is a problem with 3D charts so if you're going to go down this route when exploring your own data I highly recommend using software that allows for user interaction through rotation and zooming.

In summary, scatter plots are a simple and often effective way of visualizing bivariate data. If, however, your chart suffers from overplotting, try reducing point size and opacity. Failing that, a 2D histogram or even a 3D surface plot may be helpful. In the latter case be wary of occlusion.

Register Now for Infragistics’ Webinar series on migration from desktop technologies to web-based environment

0
0

The concept of migrating from desktop application to web technologies has been on the commercial scene for the past few years. With the success and popularity of services like SoundCloud, which gives you the freedom to listen your favorite tracks with absolutely no constraints on devices and no download required, more and more people now realize the huge potential and usability this transition will have in the enterprise world. Smartphones and tablets have become an inseparable part not only of people’s everyday life but they are getting into our professional lives at full speed as well. With executives in business-trip mode so often, those who want to work from home or on their commute and so many inventory situations, where a portable device to do the job is needed, the concept of enabling people to work comfortably outside the office is arguably taking a center stage these days.

The migration from desktop applications to modern web-based environment though can be an overwhelming and challenging process, especially when options on the table are far from clear.

At Infragistics we know that, and we’ve created a webinar series to make things much clearer and easier for you, featuring the solutions offered in our latest release of Infragistics Ultimate 15.1. These webinars cover everything from design and prototyping to development so you can get an in-depth overview of the whole process, which will have you building beautiful, high-powered web applications with greater reach, easier deployment, and lower total cost of ownership, in no time.

The series will be an ideal meeting point for desktop and web developers, UX architects, visual designers and anyone who is involved in the transition of moving either an existing desktop technology or server side web applications, which are not working well on devices.

Starting with our first webinar this Thursday, the 23rd, our Director of User Experience Kevin Richardson will reveal to you why it is so important to have a UX strategy when embarking on this important transition. Taking an existing desktop application and having it looked the same way but available on web is not as simple as it sounds. There are many aspects that need to be considered such as various design patterns, which allow you to use the application differently when you can access it remotely without being dependent on your office desk.

The following week, on the 30th of April, our very own George Abraham will show us the prototyping wonders which Infragistics’ Indigo Studio can do for your line-of-business development process. Being first with new and useful products on the market and staying ahead of the curve has always been crucial for businesses, but nowadays this process takes a whole new level. Brand new products or updated versions are out on the market in shorter time than the changing of the seasons. This change, however, includes a solid investment from enterprises in infrastructure, developer’s time, and knowledge, which in turn significantly raises the total cost of ownership. When prototyping with Indigo studio, you will not have to worry about whether the idea is good or not as your prototypes will help you determine this right from the beginning, before even writing a single code line, saving you valuable time and financial costs.

Our final presentation on the 7th of May, featuring Infragistics’ Director of Product Development Ambrose Little, will explore in detail the challenges found in enterprise-grade desktop applications, and will investigate the ways that migrating to the web will ultimately lower the cost of new software. Ambrose will also walk you through the technologies developers need to learn when starting that transition, using Infragistics’ jQuery/HTML5 toolset Ignite UI to help  you create high-performance web applications.

As an added bonus, all attendees will be entered into a raffle to win a free iPad Mini 3! Space is limited, so reserve your spot today. When you register for one webinar, you automatically gain access to all three – we make it easy!

We hope to see you in  the front row: the knowledge and practices our market-leading experts will share with you will certainly give you the competitive edge in your development process, and will provide your business undeniable benefits as well. Register here!

Upcoming Webinar: The Top 3 Must-Haves for a Successful Enterprise Mobility Solution

0
0

Upcoming Webinar: The Top 3 Must-Haves for a Successful Enterprise Mobility Solution

$284 billion – that’s the astonishing projected value for the global market for BYOD and enterprise mobility solutions by 2019. Currently valued at $72 billion, MarketsandMarkets expects an annual growth of 26.6 percent in the mobile enterprise business application market with North America as the largest region in terms of market size.

Without any doubt, enterprise mobility enablement has become a high-priority task in the strategy of many of today’s CIOs. Mobility, though, is no longer about simply supporting access to company email on certain devices. Enterprise mobility is about digital transformation and rethinking the ways employees engage with technologies to do their job whenever and wherever they are.

Pressured by BYOD (Bring Your Own Device) trends, executive and line-of-business manager needs, and a fast-moving mobility market, CIOs feel the need to embrace the right enterprise mobility solution, and to do so quickly. Making the decision on which technologies, platforms, and devices to use in order to mobilize their workforce comes with a number of challenges.

In our upcoming webinar “The Top 3 Must-Haves for a Successful Enterprise Mobility Solution”, Anand Raja, Global Solutions Consulting Manager at Infragistics and Technical Evangelist, will explore the 3 secrets of successfully leveraging your mobility opportunities and will show you how to capitalize on mobile platforms.

Mobile opportunities in front of enterprises are numerous – the question is, which ones should you pick and how can you utilize them in the most efficient way? Register now for our webinar and find out on April 30th - Reserve your spot today!

SharePlus for SharePoint - Download for Android

Windows RT is dead. What does that mean for Apps?

0
0

After an enthusiastic launch in 2012, Windows RT (Microsoft’s tablet which looked, but didn’t perform like Windows 8) received a cool welcome from consumers, lost the support of hardware manufacturers and has now been dropped by Microsoft too. Until now, Windows developers have been writing apps differently for Microsoft’s different hardware and operating systems, coding for different screen shapes and sizes. However, with the dropping of Windows RT, Microsoft are signalling a change in course when it comes to building apps for their diverse platforms.

Microsoft are now making a lot of noise about universal apps which promise to help designers write for all devices in C++, C# and JavaScript from Visual Studio. Using the Universal Windows app template, it should be a lot easier to translate your code to the specifics of different devices and systems. For developers in the Microsoft universe, getting to grips with this new approach will be essential. Already available for app design in Windows 8.1 for desktop and mobile, the universal app designer will be ubiquitous in Windows 10. This is all part of a broader move to unify and streamline coding in an increasingly diverse and specialized marketplace and it’s a considerable undertaking on Microsoft’s part.

Why did the old model need to be replaced?

Microsoft is indeed a massive corporation, and if these figures are to be believed, were it a country it would outstrip the economy of Croatia. Given its size and range of offerings - from software to hardware and consumer to business markets - it’s hardly surprising that the architecture behind its many tools is diverse. While a rich mix of tools and approaches can be a strength, it can also lead to flabbiness and confusion. At present, developers need to write apps for Microsoft’s different systems in different ways and this makes building apps for Windows a complex and challenging task.

Windows RT was a classic example of the limits to this approach. While it received some good reviews, it was simply too limited to become popular. Developers needed to write apps for Windows RT differently to how they wrote apps for Windows 8. Since it didn’t include many apps to begin with, few consumers bought into the system and, surprise, surprise, few developers wanted to put in the effort of writing apps that no one would use.

What are Universal apps and what to expect from them?

Dropping Windows RT must have been a blow for Microsoft, but their new approach demonstrates a willingness to adapt and be pragmatic. Put simply, Microsoft have adjusted their approach to the diversity of modern devices by reigning in the enormous number of APIs and frameworks which are currently proliferated around their empire. Rather than having many different ways of writing code, the plan is to offer one single place to write for all the different devices.

What this means is that you’ll no longer have to write different code for different devices - Visual Studio will take care of this for you. Whether it’s for tablet, Windows phone, laptop or PC, the apps you write will be configured for the specifics of each. Whatever the hardware, users will experience a consistent design and UX and appropriately tailored experiences for their devices. Additionally, all Windows apps will now be available in one Store and this should save developers a lot of time.

Universal app design is in fact already available for apps running from Windows 8.1. However, come the release of Windows 10 (which could be as soon as mid-2015), this will become the way of building apps for the future. Windows are a little cagey about exactly when all this will be ready. Nonetheless, more information will be released over the coming months prior to launch and you can get an idea of what it will look like here. For those who have developed apps for previous versions Microsoft have produced some handy guidelines on how you can upgrade your ready built apps to the universal model.

One code everywhere

The explosion in hardware and types of device over the last few years has produced a revolution in design and technology. It’s an exciting time to build apps but the challenges for of writing code for the diversity of devices available is also considerable. Windows Universal apps is a signal that one of the industry’s giants is responding to this change however.

Going further, tools like Xamarin.Forms take the idea of writing in one code and then let designers build amazing User Experiences for different operating systems. Given the range of products out there, allowing developers to write in one language for all platforms is an important offering from Microsoft, and we’re looking forward to seeing how this simplifies coding in the future. 

Developer Humor: Grocery Shopping

0
0

This is an absolute classic for you to enjoy on this hump-day. I've seen quite a few iterations of this joke over the years, but I've actually never seen it illustrated... so here you go!

Share With The Code Below!

<a href="http://www.infragistics.com/products/wpf"><img src=" http://www.infragistics.com/community/cfs-filesystemfile.ashx/__key/CommunityServer.Blogs.Components.WeblogFiles/d-coding/6153.Tech-toon-_2D00_-2015-_2D00_-med-res-06.jpg " height="3406" width="612" /> </a><br /><br /><br />Grocery Shopping by Infragistics <a href="http://www.infragistics.com/products/wpf">WPF Controls</a>

Three iOS UX elements to use in your App

0
0

Since the release of iOS7, App developers and designers have been adjusting to a whole new look in the Apple universe. Accustomed to embellishments and rich layers, the development community were taken by surprise with the shift to a very flat, simple interface. Regardless of your take on this, design and development for iOS will require a different approach to building apps if you wish to be consistent with Apple’s new look. Given this context it’s worth reviewing popular elements for iOS UX design and thinking imaginatively about how they can be used most effectively.

There are a number of considerations any developer needs to take into account when building for the iTunes store; successful app design is all about planning, testing and reviewing. It’s also important to maintain consistency across the app, both in terms of aesthetics but also when it comes to functioning and layout - users get spooked easily and will drop your app if it’s confusing. Good practice is to imitate the workings of native apps as users will feel instantly at home with your developments, although for immersive experiences such as games this is not necessarily the case.

Whether you have the greatest idea for a lifestyle tool, a travel planner or a weight loss programme, User Experience (UX) should run through everything you do. It’s essential to think how end-users will employ your app to do what they need and whether it will make sense to them. In this post we’ll look at three iOS UX elements which, when deployed effectively, make using your apps a joy.

1. Animations

As insignificant as they can seem, the animations which run through your apps can have an enormous impact on UX. They can turn your build from something purely functional and to a tool which is a real pleasure to turn on. 

When thinking about the kinds of animations you want to use therefore, it’s necessary to bear in mind those same UX essentials: consistency and needs of the user. Animations can have a variety of purposes:

 

  • Communicate and feedback to the user what is going on. The classic example of a spinning sand timer tells users something is loading so they don’t feel lost as to what the app is doing
  • Animations enhance the sense of direct manipulation. As technology develops, the more we want to forget we’re actually dealing with an interface. So, vibrations, pages which move like paper ones or the impression that pages are physically on top of others make users feel more at home
  • Animations can also help users visualize the results of their actions; buttons which seem to ‘push in’ when tapped also give users greater confidence in what they’re doing

 

With all the variety of possible animations out there, it can become tempting to use them heavily throughout your product. This is fine for immersive video games, but their overuse can become confusing and even slow down the app. You should therefore employ them sparingly; ideally users shouldn’t even notice they’re there!

2. Represent data and ideas succinctly

At base, a large proportion of apps are about conveying information of some sort to their users. Whether it’s baseball statistics, healthcare figures or economic forecasts, capturing this data in a clear way really improves the UX. However, too many apps demonstrate these figures in bland or confusing ways and when set out in tedious tables, data becomes hard to read and correlations difficult to comprehend. Tools which allow you to build visual representations of information can really improve UX however.

3. Typography - words are only half the story

In the new iOS, the flatness of the interface is married with a new approach to typography. Apple have replaced many buttons and icons with text. While it can occasionally be less clear what a button is and what’s simply text, it does make reading what they say a lot easier.

If, in your app, you decide to imitate Apple’s new approach or not, thinking about the layout of your content is essential. It’s recommended to never show text below font size 11 and also plan for users zooming in and out - be sure that your dynamic type auto-adjusts spacing and height.

As before, the real key with UX is consistency and thinking about end-user needs. Of course, keep styles consistent throughout your build but also consider what they look like:

 

  • Does your font colour show up against the background?
  • Do size adjustments correspond with what the user wants to read?
  • Does text show up clearly in different lights?

 

Don’t tempt me!

Considering the variety of touches, tones, colours and visualizations available, it can be tempting to go overboard on your app UX. However, as the saying goes, less is more. The above UX elements are important things to take into account when you design apps, but by far the most important points to bear in mind are about consistency and user needs. Regularly asking yourself if the design is consistent with other pages and if it actually serves a user need will help focus your work and turn your apps into streamlined and extraordinary experiences.

Want to know how your Web, desktop, or mobile application idea will look and work before even writing a single code of line? Here is the solution for you. Download our Indigo Studio free trial now and see this rapid prototyping tool in action!



Open source .NET: CoreCLR now on GitHub

0
0

At the beginning of February, Microsoft announced their release of CoreCLR on GitHub, where developers can now get their hands on the roughly 2.6 million lines of source code of which it is comprised. This move comes as part of their wider open sourcing of the .NET Core and a lot of people are already finding interesting ways of using the code. The releases are currently restricted to Windows, but will soon be available in Linux and Mac OS too (although there are means of getting at it already from different Operating Systems as this article explains).

We looked at Microsoft’s choice to begin outsourcing some of their proprietary coding in an earlier post and it’s exciting to see how these releases are panning out. For years - ever since they released .NET in 2002 - this information was kept well under wraps. The community are, of course, ecstatic about this move and for many, the ability to access, fork, clone and copy Microsoft’s fundamental codes is a big deal. What this means for developers, how the community can get involved and what the repercussions of Microsoft’s open sourcing will be are all compelling questions. In this post we’ll be delving into these issues.

CoreCLR - an overview

The .NET Framework is built out of a collection of interrelated architectures which relate to one another and is mainly written in C#. The CoreCLR fits in underneath the various parts of this structure and has the fundamental role of compiling code into machine language. It also has other functions such as garbage collection and IL bytecode loading.

Microsoft have explained that since originally launching .NET, they’ve gradually built in various verticals with different APIs into the overall architecture which have the same source code. Each of these projects was run by different teams and gradually ended up working at different paces on different projects. This was fine to begin with but it eventually became clear that building in horizontal components shared across the different verticals was becoming increasingly complex. The underlying aim of the .NET Core project therefore, is to write one code base which is interoperable across the whole platform and the choice to invite the developer community in here is part of a bid to gradually improve the whole structure. Open Sourcing CoreCLR was therefore a necessary but significant step in this process.

How can developers get involved?

Besides diving straight in and playing with CoreCLR’s code, there are a number of sources of guides and information on the release. The Mono Project is aimed at supporting the open sourcing of the .NET framework in general and it has handy guides for developers including a specific wiki for CodingCore CLR and this is a great place to start. Mono also has a community section where questions and topics can be discussed. In addition, GitHub also includes developer guides for working on CoreCLR.

So what’s Microsoft's game plan? 

There’s a variety of reasons that Microsoft are going down this route of open sourcing their code bases. While for many coders this is a dream come true - and something they’ve been waiting on for years - Microsoft have bigger motives than simply keeping the coding community happy. In many ways the CoreCLR is their “secret ingredient”, so releasing it to the world at large might seem like an illogical move. Why let everyone get their hands on the highly advanced code they’ve kept secret for so long; is this not a risky strategy?

It says a lot about Microsoft’s confidence of their place in the world that they’re ready and willing to reveal this information at all; only a company which is so assured of its relevance would take such a step. However, beyond this, there are a number of other reasons why they would release this data.

To a degree, Microsoft are drawing on the intelligence of the crowd. In their announcements about open sourcing, Microsoft have expressed their confidence in the open source community - through long experience they’ve come to recognize that collaboration with the community can in fact be very useful. When developers fork, clone and copy code they can make real contributions to Microsoft’s overall plans of developing .NET.

It’s a win win situation however, as developers too can take advantage of this information. It can help inform builds and projects, and give an insight into Microsoft’s internal code writing, which really is state of the art.

Get involved

By making CoreCLR available on GitHub, Microsoft have demonstrated their dedication to a more transparent and open business model, yet also displayed their confidence in their position in the world. For devs this is also an exciting opportunity to contribute to .NET and help better understand Microsoft’s work.

Want to see what the fastest grid on the market can do for you? Download Infragistics ASP.NET Data Grid and enjoy the ride!

 

See You at Build!

0
0

If I wasn't excited enough about heading out to the Bay Area next week for Microsoft's //BUILD, with my Infragistics colleagues, earlier today in Malta Microsoft's General Manager of Developer Experience, Bryan Biniak made some interesting commentary about the news we'll be hearing at next week's event.

It's common knowledge that we're in the midst of Windows 10's marketing and impending launch, but the surprise that Bikiak alluded to in his special press session was that there are "new products and services" that will also be announced at next week's big event.

What is Microsoft announcing next week? Do you have any guesses?

You can bet that I'll be there right beside you to hear the news at //BUILD. Make sure to visit me at booth #313 and pick up one of Infragistics' brand new surprise t-shirts. What are they? You'll just have to stop by to find out!

See you soon! If you need to reach the Infragistics event team while we're on site at the event and can't get to the booth, feel free to tweet @Infragistics or directly to me @DokiDara. We're happy to help you!

What is a Windows Universal App and why should I care?

0
0

One of the key drivers behind a mobile or desktop platforms’ success are the number of apps available in its corresponding app store. The Windows Phone store is catching up, but is still very much behind iOS and Android. The Windows store faces the same issue - it just does not contain enough apps (although it’s improving).

The biggest issue Windows 8 and Windows Phone 8.1 stores had was that they were two separate stores. So, if you wanted to build an app for both Windows 8 and Windows Phone 8, you’d have to create two apps. It was possible though to reuse code between those two apps, using Portable Class Libraries, but reusing UI was not possible.

Microsoft acknowledged this issue, and has introduced the solution: Universal Apps. Universal apps allow developers to create one app, and deploy it to both the Windows 8 and Windows Phone 8 stores. You are now able to create a different package for each store with a single action; your app will be published to all users with a Windows device! This brings some major benefits to end users too: their identity is shared between the Windows 8 and Windows Phone app and purchases are synchronized so users only have to buy the app once.

Windows 8.1 vs Windows 10

There are subtle differences between Universal apps for Windows 8.1 and for Windows 10. In Windows 8.1, you’ll still create two app packages when publishing. One for Windows 8.1 and one for Windows Phone 8.1 as the two still technically use different stores. Windows 8.1 and Windows Phone 8.1 share a lot of code, user controls and templates, but still require custom code for each platform.

In Windows 10 this has changed. The two app stores have been merged into one store: The Windows 10 store. You only create one package, and it will be available on any Windows device. This also allows you to virtually reuse all code between Windows 10 for mobile, tablets, and desktop devices.

The rest of this post is split in two parts, one aiming at Windows 8.1 & Windows Phone 8.1, and one at Windows 10. Before opening Visual Studio, make sure you have updated to at least Visual Studio 2013 Update 2. We also focus on Visual C#, but you can use the language of your choice.

Build a Universal App for Windows 8.1 and Windows Phone 8.1

Open File -> New Solution and open the following template category: Visual C# => Store Apps -> Universal Apps.

  • The Blank App will create an almost empty solution, with no pre-baked code. You’ll have to create everything yourself.
  • The Hub App contains a three-page universal app that uses a Hub control. The Hub control is very useful for content that can be organized in different sections or categories.
  • A portable class library is a project template that allows for reusable components. It will be created for you when you choose Blank App or Hub App, but you may want to add more class libraries later on.
  • Windows Runtime Component: This project type is necessary when you want to build a JavaScript app, and run compiled code in a DLL.

 

The future: Build a Universal App for Windows 10

Windows 10 will be released this year and the big difference is that the Windows 8.1 and Windows Phone 8.1 stores will merge into the Windows 10 store. Every app will run on every available Windows 10 device, and will adapt to the device specifications. Universal apps for Windows 10 allows you to create one single app for all devices, and configure it to render as required.

In Visual Studio, go to File -> New Solution and browse to the category Visual C# -> Windows 10.

  • Blank Application creates a new, empty Windows 10 universal app,
  • Class Library and Windows Runtime Component: See the earlier description in the section about Windows 8.1 universal apps.
  • The Unit Test App template is a project template to create unit tests for a Windows 10 universal app.

 

The biggest challenge in a Windows 10 app is to design your pages to render properly on every device. The same page will be used on a Windows 10 desktop machine with Full HD resolution and on a Lumia 530 Windows 10 mobile phone with “only” 854 x 480 resolution. New controls have been introduced to help you achieve this, e.g. the RelativePanel and SplitView controls. Read more about adaptive controls here.

Reach more people with less effort

The introduction of Universal apps enables developers to create one app and publish it to multiple platforms. In Windows 10 this will be even better, as it will be truly one single app, whereas in Windows 8.1 the mobile and desktop/tablet app stores are still two different entities.

The future could be very exciting indeed. Windows 10 will be a free upgrade for all existing Windows 7 & 8 users, and apps will be available to a very big audience. Creating apps for both tablet/ desktop devices and mobile phones will be very easy with universal apps. By providing a universal app, customers with multiple devices will have a seamless experience between laptops, desktops, phones and tablets!

On the lookout for creating amazing native experience with mobile controls ? Here is your best stop - get Infragistics Windows Phone Controls now as part of the ULTIMATE Developer toolkit for a Free 30-day trial!


Prototyping a Sales Dashboard for a Mobile Device

0
0

[youtube] width="560" height="315" src="http://www.youtube.com/embed/qqmkv_DrTGw" [/youtube]

In this video we created an Indigo Studio prototype to design the global sales dashboard for a mobile device form factor - an iPhone 6 to be precise! Much of the design that was introduced in the tablet version has also been implemented here, so I'm going to go ahead run the prototype so you get a better idea on how the  interactions of the design work on a mobile device.

The landing screen of the phone version shows three zones: month to date, quarter to date, and year to date figures. If someone is interested in any of the zones, they can just go ahead to drill down.

Here it shows the breakdowns of the sales figures by different regions and I can change to different divisions. I can access the chart from bottom. If I am interested in particular segment, for example the region of Americas, I can also access the chart of that particular segment from one click. It will demonstrate the global sales Americas from the chart.

If I decide to change to a different time range, for example, if I'm interested in the figures of previous months of sales figures, I can do so by swiping the time range up or down. Now I changed to June 2015. Because June falls into the second quarter, the quarter also reflects a change to Q2 that spans from April to June, and that is still within the range of 2015. So any of the time range change will also be reflected from other time ranges.

In this Indigo Studio prototype we were able to what the sales dashboard will look like on a mobile device. It helped us test the interactions and the navigations before the dashboard was developed, which in the end saved valuable time and money. To explore this for yourself, you can download the Indigo Studio files here.

Developer News - What's IN with the Infragistics Community? (4/20-4/27)

0
0

Live from the west coast this afternoon, I'm bringing you your Developer News! This week has some highlights from Visual Studio Community 2013, as well as some awesome UX insight. Check it out and I hope you enjoy!!

5. 3 Life Lessons I Learned from Coding (Lynda)

4. Introducing Visual Studio Community 2013 (Channel 9)

3. Communicating UX Goals Through Interface Design (Vandelay Designs)

2. 10 Things to Know Before You Become a Programmer (DevBattles)

1. Techniques for Breaking Down Technically Complex User Stories (Agile42)

Localize Property Names, Descriptions, and Categories for the XamPropertyGrid

0
0

I was browsing the Infragistics WPF Forums the other day and ran into this question asking how to localize the descriptions of properties in the xamPropertyGrid control.  The original poster looked at other solutions including the use of attributes, but thought those solutions were overly complicated and not very straightforward.  Of course my first thought was “then they’re are doing it wrong”.  So I wanted to see if I could adapt my blog post about how to localize Enum descriptions in WPF to accommodate the xamPropertyGrid, but take it a little further by also localizing the DisplayName and Category as well.  I mean heck, we are in a property grid with a lot of property information, why localize just the Description?  Heck no, let’s localize it all!

Adding Localization Support

My first step was to use my LocalizedDescriptionAttribute“as-is” from my other post to see if it would just work.  So I just copied and pasted this class into my project.

publicclassLocalizedDescriptionAttribute : DescriptionAttribute
{
    readonlyResourceManager _resourceManager;
    readonlystring _resourceKey;

    public LocalizedDescriptionAttribute(string resourceKey, Type resourceType)
    {
        _resourceManager = newResourceManager(resourceType);
        _resourceKey = resourceKey;
    }

    publicoverridestring Description
    {
        get
        {
            string description = _resourceManager.GetString(_resourceKey);
            returnstring.IsNullOrWhiteSpace(description) ? string.Format("[[{0}]]", _resourceKey) : description;
        }
    }
}

Now, I wanted to add support for the DisplayName and for the Category of the properties.  So I created two other classes that used a very similar approach that I used for the LocalizedDescriptionAttribute.

The LocalizedDisplayNameAttribute looks almost identical.

publicclassLocalizedDisplayNameAttribute : DisplayNameAttribute
{
    readonlyResourceManager _resourceManager;
    readonlystring _resourceKey;

    public LocalizedDisplayNameAttribute(string resourceKey, Type resourceType)
    {
        _resourceManager = newResourceManager(resourceType);
        _resourceKey = resourceKey;
    }

    publicoverridestring DisplayName
    {
        get
        {
            string displayName = _resourceManager.GetString(_resourceKey);
            returnstring.IsNullOrWhiteSpace(displayName) ? string.Format("[[{0}]]", _resourceKey) : displayName;
        }
    }
}

But, the LocalizedCategoryAttribute has a slight modification.  I had to override the GetLocalizedString method.  Other than that, the logic is the same.

publicclassLocalizedCategoryAttribute : CategoryAttribute
{
    readonlyResourceManager _resourceManager;
    readonlystring _resourceKey;

    public LocalizedCategoryAttribute(string resourceKey, Type resourceType)
    {
        _resourceManager = newResourceManager(resourceType);
        _resourceKey = resourceKey;
    }

    protectedoverridestring GetLocalizedString(string value)
    {
        string category = _resourceManager.GetString(_resourceKey);
        returnstring.IsNullOrWhiteSpace(category) ? string.Format("[[{0}]]", _resourceKey) : category;
    }
}

Now we can go ahead and add a couple of Resource.resx files to the project and target your desired cultures.  I am supporting English and Japanese (Nihongo).

Person resources

PersonResources.resx(English)

english person resources

PersonResources.ja-JP.resx (Japanese)

japanese person resources

Since we have resources, we need some properties to start localizing.  I’ll keep it simple and just use a Person class with a single property.

publicclassPerson
{
    [LocalizedDisplayName("NameDisplayName", typeof(PersonResources))]
    [LocalizedDescription("NameDescription", typeof(PersonResources))]
    [LocalizedCategory("PersonCategory", typeof(PersonResources))]
    publicstring Name { get; set; }
}

Let’s run our app and see what we have.  The default will be our English resources.  This means all of the values being displayed are being retrieved from the PersonResources.resx file.

xamPropertGrid localized with English

What happens when we want to change to use our Japanese localized values?  Well, let’s find out.  Open up your App.xaml.cs and override the startup method and change the culture.

protectedoverridevoid OnStartup(StartupEventArgs e)
{
    CultureInfo info = newCultureInfo("ja-JP");
    Thread.CurrentThread.CurrentCulture = info;
    Thread.CurrentThread.CurrentUICulture = info;
}

Now, run the applications again.

xamPropertyGrid localized with Japanese

Works like a charm!  It is obvious that our values are being retrieved from our Japanese resources stored in the PersonResources.ja-JA.resx file.

Pretty slick, right?  I don’t think this is overcomplicated or difficult to follow at all.  Looks pretty straight forward to me.  What do you think?  Hopefully you will find this useful, and maybe even use this approach in your WPF applications.  Be sure to check out the source code, and start playing with it.  As always, feel free contact me on my blog, connect with me on Twitter (@brianlagunas), or leave a comment below for any questions or comments you may have.

Touch Enabled Scenarios with Infragistics Windows Forms Components

0
0

Infragistics Windows Form controls offer opportunities to cover different scenarios and represent data in your desktop applications. This toolkit is one of the best, most extensible third party controls that I have ever used for UI development. With more than 100+ controls, Infragistics Windows Forms is the most mature, fully-featured Windows Forms Product on the market. With features that cover every aspect of enterprise software development including Microsoft Office Style user interfaces, high performance charting, and full modern experiences with touch gestures, these controls were built to empower you to create Touch-Enabled, Office Inspired Apps on Every Platform.

In this article we will discuss some common scenarios when you need to have touch support and then we'll explore some useful examples of how to implement it.

Touch Enabled Concept

Prior to Windows 7, Windows Forms controls did not natively support gestures of user interaction with a touch input digitizer surface through managed code. You may administer Windows7 supported WM_GESTURE message in unmanaged code to provide support for the recognized Windows gestures.

One well-known gesture, kinetic scrolling with inertia (also referred to as touch panning) occurs when the user drags a finger across a touch surface, with the speed and direction of the movement determining the direction of and speed at which the window scrolls. The scrolling continues, even after the user withdrawals his or her finger, gradually decelerating before coming to a complete stop, a behavior known as panning inertia. Any user interaction occurring during this deceleration immediately stops the inertial panning. This behavior is prevalent on smart phones and tablet devices such as iPhone, iPad and Windows touch-enabled Surface devices.

Another application of the panning gesture is drag selection, where the user drags a lasso around the screen, selecting any items captured within the bounds of the lasso rectangle.

Other gestures also have default behaviors associated with them, for example, displaying a context menu using a press-and-hold gesture. This is where the user holds a finger down on the touch surface without moving it and displays a context menu after a short time.

What you need to know

The size of the Infragistics Windows Forms touch-enabled controls may be the first thing you notice. By design, touch-enabled controls appear larger (wider, taller or both) than buttons and other elements in the User Interface (UI) making it easier to interact with and operate when using a touch-sensitive surface.

Enabling the touch functionality occurs at the form level rather than the control level, as it is unlikely that both Touch and Non-Touch system use the same application. Adding the UltraTouchProvider component to the form enables Form level touch support for NetAdvantage controls.

Although other approaches were analyzed for enabling Touch functionality at the application level, none appeared to be a feasible solution allowing you to interact with the touch metrics at design-time to arrange controls on the form using the designer. The only way to enable touch at the application level is via the static property. Since the static property is not available at design-time, best practice dictates enabling the touch functionality at the Form level.

Touch Support Controls

 

 

 

 

Touch Experience

Touch Metric Suport

Resize elements of the Grid, Editor, List View, Tree, Tab, and Tabbed MDI controls to make them larger for better touch interactivity.

Touch-Metric-Support[1]

 

Panning Gesture Support

The Grid, Tree, and List View controls are enabled with support for panning gestures, including vertical, slow, fast, and multi-directional panning and flicking. Additionally the Combo, Combo Editor, and Value List support vertical scrolling via the panning gesture.

Touch-panning[1]

Multi-Gesture Support

The Grid, Tree, and List View controls support key multi-gesture functionality, including tap, tap & drag, double tap, and tap & hold.

 

Touch-Multigesture[1]

 

Code Samples

Touch Tab Controls

windows-forms-touch-experience-touch-tab-controls-en-us[1]

 

 1:using System;
 2:using System.Globalization;
 3:using System.Windows.Forms;
 4:using Infragistics.Win;
 5:using Infragistics.Win.UltraWinTabControl;
 6:using Infragistics.Win.UltraWinTabs;
 7:  
 8:namespace TouchEnabledTabControls.CS
 9: {
 10:publicpartialclass TabControlsForm : Form
 11:     {
 12:#region Constructor
 13:public TabControlsForm()
 14:         {
 15:             InitializeComponent();
 16:         } 
 17:#endregion
 18:  
 19:#region TabControlsFormLoad
 20:privatevoid TabControlsFormLoad(object sender, EventArgs e)
 21:         {
 22:// Set the ComboEditors with default display value.
 23:             ultraComboEditor_Tab_ScrollButtons.SelectedIndex = 2;
 24:             ultraComboEditor_Tab_CloseButtons.SelectedIndex = 1;
 25:             ultraComboEditor_Tab_Style.SelectedIndex = 0;
 26:  
 27:             ultraComboEditor_TabStrip_ScrollButtons.SelectedIndex = 2;
 28:             ultraComboEditor_TabStrip_CloseButtons.SelectedIndex = 1;
 29:             ultraComboEditor_TabStrip_Style.SelectedIndex = 0;
 30:         } 
 31:#endregion
 32:  
 33:#region BtnEnableTouchClick
 34:privatevoid BtnEnableTouchClick(object sender, EventArgs e)
 35:         {
 36:             ultraTouchProvider1.Enabled = !ultraTouchProvider1.Enabled;
 37:             btnEnableTouch.Text = ultraTouchProvider1.Enabled ? Properties.Resources.Button_Disable_Touch : Properties.Resources.Button_Enable_Touch;
 38:         }
 39:#endregion
 40:  
 41:#region WinTab Control events
 42:  
 43:#region UltraComboEditorTabScrollButtonValueChanged
 44:// Show Scroll Buttons
 45:privatevoid UltraComboEditorTabScrollButtonValueChanged(object sender, EventArgs e)
 46:         {
 47:             var cb = ultraComboEditor_Tab_ScrollButtons;
 48:if (cb == null || cb.SelectedItem == null)
 49:return;
 50:  
 51:             var item = cb.SelectedItem.DisplayText;
 52:  
 53:switch (item)
 54:             {
 55:case"Default":
 56:                     ultraTabControl1.ScrollButtonTypes = ScrollButtonTypes.Default;
 57:break;
 58:case"FirstLast":
 59:                     ultraTabControl1.ScrollButtonTypes = ScrollButtonTypes.FirstLast;
 60:break;
 61:case"NextPrevious":
 62:                     ultraTabControl1.ScrollButtonTypes = ScrollButtonTypes.NextPrevious;
 63:break;
 64:case"NextPagePreviousPage":
 65:                     ultraTabControl1.ScrollButtonTypes = ScrollButtonTypes.NextPagePreviousPage;
 66:break;
 67:case"None":
 68:                     ultraTabControl1.ScrollButtonTypes = ScrollButtonTypes.None;
 69:break;
 70:case"Thumb":
 71:                     ultraTabControl1.ScrollButtonTypes = ScrollButtonTypes.Thumb;
 72:break;
 73:             }
 74:         }
 75:#endregion
 76:  
 77:#region UltraComboEditorTabCloseButtonValueChanged
 78:// Show Close Buttons
 79:privatevoid UltraComboEditorTabCloseButtonValueChanged(object sender, EventArgs e)
 80:         {
 81:             var cb = ultraComboEditor_Tab_CloseButtons;
 82:if (cb == null || cb.SelectedItem == null)
 83:return;
 84:             ultraTabControl1.CloseButtonLocation = (TabCloseButtonLocation)cb.SelectedIndex;
 85:         }
 86:#endregion
 87:  
 88:#region UltraComboEditorTabStyleValueChanged
 89:// Select a Style (NotePage)
 90:privatevoid UltraComboEditorTabStyleValueChanged(object sender, EventArgs e)
 91:         {
 92:             var cb = ultraComboEditor_Tab_Style;
 93:if (cb == null || cb.SelectedItem == null)
 94:return;
 95:  
 96:             var item = cb.SelectedItem.DisplayText;
 97:  
 98:switch (item)
 99:             {
 100:case"Default":
 101:                     ultraTabControl1.Style = UltraTabControlStyle.Default;
 102:break;
 103:case"NotePage":
 104:                     ultraTabControl1.Style = UltraTabControlStyle.NotePage;
 105:break;
 106:case"NotePageFlat":
 107:                     ultraTabControl1.Style = UltraTabControlStyle.NotePageFlat;
 108:break;
 109:             }
 110:         }
 111:#endregion
 112:  
 113:#region UltraCheckEditorTabShowListButtonCheckedChanged
 114:// Show TabList button
 115:privatevoid UltraCheckEditorTabShowListButtonCheckedChanged(object sender, EventArgs e)
 116:         {
 117:             ultraTabControl1.ShowTabListButton =
 118:                 ultraTabControl1.ShowTabListButton != DefaultableBoolean.True ? DefaultableBoolean.True : DefaultableBoolean.Default;
 119:         }
 120:#endregion
 121:  
 122:#endregion
 123:  
 124:#region WinTabStrip Control events
 125:  
 126:#region UltraComboEditorTabStripScrollButtonValueChanged
 127:// Show Scroll Buttons
 128:privatevoid UltraComboEditorTabStripScrollButtonValueChanged(object sender, EventArgs e)
 129:         {
 130:             var cb = ultraComboEditor_TabStrip_ScrollButtons;
 131:if (cb == null || cb.SelectedItem == null)
 132:return;
 133:  
 134:             var item = cb.SelectedItem.DisplayText;
 135:  
 136:switch (item)
 137:             {
 138:case"Default":
 139:                     ultraTabStripControl1.ScrollButtonTypes = ScrollButtonTypes.Default;
 140:break;
 141:case"FirstLast":
 142:                     ultraTabStripControl1.ScrollButtonTypes = ScrollButtonTypes.FirstLast;
 143:break;
 144:case"NextPrevious":
 145:                     ultraTabStripControl1.ScrollButtonTypes = ScrollButtonTypes.NextPrevious;
 146:break;
 147:case"NextPagePreviousPage":
 148:                     ultraTabStripControl1.ScrollButtonTypes = ScrollButtonTypes.NextPagePreviousPage;
 149:break;
 150:case"None":
 151:                     ultraTabStripControl1.ScrollButtonTypes = ScrollButtonTypes.None;
 152:break;
 153:case"Thumb":
 154:                     ultraTabStripControl1.ScrollButtonTypes = ScrollButtonTypes.Thumb;
 155:break;
 156:             }
 157:         } 
 158:#endregion
 159:  
 160:#region UltraComboEditorTabStripCloseButtonValueChanged
 161:// Show Close Buttons
 162:privatevoid UltraComboEditorTabStripCloseButtonValueChanged(object sender, EventArgs e)
 163:         {
 164:             var cb = ultraComboEditor_TabStrip_CloseButtons;
 165:if (cb == null || cb.SelectedItem == null)
 166:return;
 167:             ultraTabStripControl1.CloseButtonLocation = (TabCloseButtonLocation)cb.SelectedIndex;
 168:         } 
 169:#endregion
 170:  
 171:#region UltraComboEditorTabStripStyleValueChanged
 172:// Select a Style (NotePage)
 173:privatevoid UltraComboEditorTabStripStyleValueChanged(object sender, EventArgs e)
 174:         {
 175:             var cb = ultraComboEditor_TabStrip_Style;
 176:if (cb == null || cb.SelectedItem == null)
 177:return;
 178:  
 179:             var item = cb.SelectedItem.DisplayText;
 180:  
 181:switch (item)
 182:             {
 183:case"Default":
 184:                     ultraTabStripControl1.Style = UltraTabControlStyle.Default;
 185:break;
 186:case"NotePage":
 187:                     ultraTabStripControl1.Style = UltraTabControlStyle.NotePage;
 188:break;
 189:case"NotePageFlat":
 190:                     ultraTabStripControl1.Style = UltraTabControlStyle.NotePageFlat;
 191:break;
 192:             }
 193:         } 
 194:#endregion
 195:  
 196:#region UltraCheckEditorTabStripShowListButtonCheckedChanged
 197:// Show TabList button
 198:privatevoid UltraCheckEditorTabStripShowListButtonCheckedChanged(object sender, EventArgs e)
 199:         {
 200:             ultraTabStripControl1.ShowTabListButton =
 201:                 ultraTabStripControl1.ShowTabListButton != DefaultableBoolean.True ? DefaultableBoolean.True : DefaultableBoolean.Default;
 202:         } 
 203:#endregion
 204:  
 205:#region UltraTabStripControl1TabStripSelectedTabChanged
 206:// Selected Tab Changed event
 207:privatevoid UltraTabStripControl1TabStripSelectedTabChanged(object sender, SelectedTabChangedEventArgs e)
 208:         {
 209:             var num = e.Tab.Index + 1;
 210:             ultraTextEditor_TabStrip.Text = num.ToString(CultureInfo.InvariantCulture);
 211:         }
 212:#endregion
 213:  
 214:#endregion
 215:     }
 216: }

Touch Editors And Grid Elements

windows-forms-touch-experience-touch-editors-and-grid-elements-en-us[1]

 1:using System;
 2:using System.Windows.Forms;
 3:using Infragistics.Win;
 4:using Infragistics.Win.UltraWinEditors;
 5:using System.Drawing;
 6:using Infragistics.Win.UltraWinGrid;
 7:using ButtonDisplayStyle = Infragistics.Win.ButtonDisplayStyle;
 8:  
 9:namespace TouchEnabledEditorsAndGridElements.CS
 10: {
 11:publicpartialclass TouchForm : Form
 12:     {
 13:#region Constructor
 14:public TouchForm()
 15:         {
 16:             InitializeComponent();
 17:         } 
 18:#endregion
 19:  
 20:#region TouchFormLoad
 21:privatevoid TouchFormLoad(object sender, EventArgs e)
 22:         {
 23:// Bind UltraCombo.
 24:             ultraCombo.DataSource = new TestData();
 25:             ultraCombo.SelectedText = "Select Item";
 26:  
 27:  
 28:// Bind UltraComboEditor.
 29:             ultraComboEditor.DataSource = new TestData();
 30:             ultraComboEditor.SelectedIndex = 1;
 31:  
 32:  
 33:// Bind WinGrid.
 34:             ultraGrid1.DataSource = new TestData();
 35:  
 36:  
 37:// Display difault values in ComboEditors.
 38:             ultraComboEditor_SelectCardViewStyle.SelectedIndex = 0;
 39:             ultraComboEditor_FixedRowIndicator.SelectedIndex = 1;
 40:             ultraComboEditor_EnableSummary.SelectedIndex = 3;
 41:  
 42:  
 43:// Attach DrawFilter (RemoveFocusRectangle) to CheckEditor.
 44:// This will prevent from displaying the dotted line when the control is clicked.
 45:             ultraCheckEditor.DrawFilter = new RemoveFocusRectangle();
 46:             ultraTabControl1.DrawFilter = new RemoveFocusRectangle();
 47:             ultraOptionSet.DrawFilter = new RemoveFocusRectangle();
 48:         } 
 49:#endregion
 50:  
 51:#region Editor Controls
 52:  
 53:// Add/Remove Buttons LEFT / RIGHT
 54:privatevoid UltraCheckEditorAddButtonRightLeftCheckedChanged(object sender, EventArgs e)
 55:         {
 56:             var button1 = new EditorButton();
 57:  
 58:// Add /Remove LEFT button
 59:if (ultraCalculatorDropDown.ButtonsLeft.Count 
 60:             {
 61:                 ultraCalculatorDropDown.ButtonsLeft.Add(button1);
 62:                 ultraColorPicker.ButtonsLeft.Add(button1);
 63:                 ultraCombo.ButtonsLeft.Add(button1);
 64:                 ultraComboEditor.ButtonsLeft.Add(button1);
 65:                 ultraCurrencyEditor.ButtonsLeft.Add(button1);
 66:                 ultraDateTimeEditor.ButtonsLeft.Add(button1);
 67:                 ultraFontNameEditor.ButtonsLeft.Add(button1);
 68:                 ultraFormattedTextEditor.ButtonsLeft.Add(button1);
 69:                 ultraMaskedEdit.ButtonsLeft.Add(button1);
 70:                 ultraNumericEditor.ButtonsLeft.Add(button1);
 71:                 ultraTextEditor.ButtonsLeft.Add(button1);
 72:                 ultraTimeSpanEditor.ButtonsLeft.Add(button1);
 73:                 ultraTimeZoneEditor.ButtonsLeft.Add(button1);
 74:             }
 75:else
 76:             {
 77:                 ultraCalculatorDropDown.ButtonsLeft.RemoveAt(0);
 78:                 ultraColorPicker.ButtonsLeft.RemoveAt(0);
 79:                 ultraCombo.ButtonsLeft.RemoveAt(0);
 80:                 ultraComboEditor.ButtonsLeft.RemoveAt(0);
 81:                 ultraCurrencyEditor.ButtonsLeft.RemoveAt(0);
 82:                 ultraDateTimeEditor.ButtonsLeft.RemoveAt(0);
 83:                 ultraFontNameEditor.ButtonsLeft.RemoveAt(0);
 84:                 ultraFormattedTextEditor.ButtonsLeft.RemoveAt(0);
 85:                 ultraMaskedEdit.ButtonsLeft.RemoveAt(0);
 86:                 ultraNumericEditor.ButtonsLeft.RemoveAt(0);
 87:                 ultraTextEditor.ButtonsLeft.RemoveAt(0);
 88:                 ultraTimeSpanEditor.ButtonsLeft.RemoveAt(0);
 89:                 ultraTimeZoneEditor.ButtonsLeft.RemoveAt(0);
 90:             }
 91:  
 92:             var button2 = new EditorButton();
 93:  
 94:// Add /Remove RIGHT button
 95:if (ultraCalculatorDropDown.ButtonsRight.Count 
 96:             {
 97:                 ultraCalculatorDropDown.ButtonsRight.Add(button2);
 98:                 ultraColorPicker.ButtonsRight.Add(button2);
 99:                 ultraCombo.ButtonsRight.Add(button2);
 100:                 ultraComboEditor.ButtonsRight.Add(button2);
 101:                 ultraCurrencyEditor.ButtonsRight.Add(button2);
 102:                 ultraDateTimeEditor.ButtonsRight.Add(button2);
 103:                 ultraFontNameEditor.ButtonsRight.Add(button2);
 104:                 ultraFormattedTextEditor.ButtonsRight.Add(button2);
 105:                 ultraMaskedEdit.ButtonsRight.Add(button2);
 106:                 ultraNumericEditor.ButtonsRight.Add(button2);
 107:                 ultraTextEditor.ButtonsRight.Add(button2);
 108:                 ultraTimeSpanEditor.ButtonsRight.Add(button2);
 109:                 ultraTimeZoneEditor.ButtonsRight.Add(button2);
 110:             }
 111:else
 112:             {
 113:                 ultraCalculatorDropDown.ButtonsRight.RemoveAt(0);
 114:                 ultraColorPicker.ButtonsRight.RemoveAt(0);
 115:                 ultraCombo.ButtonsRight.RemoveAt(0);
 116:                 ultraComboEditor.ButtonsRight.RemoveAt(0);
 117:                 ultraCurrencyEditor.ButtonsRight.RemoveAt(0);
 118:                 ultraDateTimeEditor.ButtonsRight.RemoveAt(0);
 119:                 ultraFontNameEditor.ButtonsRight.RemoveAt(0);
 120:                 ultraFormattedTextEditor.ButtonsRight.RemoveAt(0);
 121:                 ultraMaskedEdit.ButtonsRight.RemoveAt(0);
 122:                 ultraNumericEditor.ButtonsRight.RemoveAt(0);
 123:                 ultraTextEditor.ButtonsRight.RemoveAt(0);
 124:                 ultraTimeSpanEditor.ButtonsRight.RemoveAt(0);
 125:                 ultraTimeZoneEditor.ButtonsRight.RemoveAt(0);
 126:             }
 127:         }
 128:  
 129:  
 130:// Add/Remove Spin button
 131:privatevoid UltraCheckEditorAddSpinButtonCheckedChanged(object sender, EventArgs e)
 132:         {
 133://var spinButton = new SpinEditorButton { Orientation = Orientation.Horizontal };
 134:  
 135:// Add /Remove SPIN button
 136:             ultraCurrencyEditor.SpinButtonDisplayStyle =
 137:                 ultraCurrencyEditor.SpinButtonDisplayStyle != ButtonDisplayStyle.Always
 138:                 ? ButtonDisplayStyle.Always
 139:                 : ButtonDisplayStyle.Never;
 140:  
 141:             ultraDateTimeEditor.SpinButtonDisplayStyle =
 142:                 ultraDateTimeEditor.SpinButtonDisplayStyle != ButtonDisplayStyle.Always
 143:                 ? ButtonDisplayStyle.Always
 144:                 : ButtonDisplayStyle.Never;
 145:  
 146:             ultraMaskedEdit.SpinButtonDisplayStyle =
 147:                 ultraMaskedEdit.SpinButtonDisplayStyle == SpinButtonDisplayStyle.None
 148:                 ? SpinButtonDisplayStyle.OnRight
 149:                 : SpinButtonDisplayStyle.None;
 150:  
 151:             ultraNumericEditor.SpinButtonDisplayStyle =
 152:                 ultraNumericEditor.SpinButtonDisplayStyle != ButtonDisplayStyle.Always
 153:                 ? ButtonDisplayStyle.Always
 154:                 : ButtonDisplayStyle.Never;
 155:         }
 156:  
 157:  
 158:// Change the color of RadioButton's label
 159:privatevoid UltraOptionSetValueChanged(object sender, EventArgs e)
 160:         {
 161:             ultraLabel_UltraOptionSet.ForeColor = ultraOptionSet.CheckedItem.DataValue.ToString()
 162:                 == "Red" ? Color.Red : Color.Blue;
 163:         }
 164:  
 165:  
 166:// Display the selected font on the label in front of the control
 167:privatevoid UltraFontNameEditorValueChanged(object sender, EventArgs e)
 168:         {
 169:             ultraLabel_UltraFontNameEditor.Appearance.FontData.Name = ultraFontNameEditor.Value.ToString();
 170:         } 
 171:#endregion
 172:  
 173:#region WinGrid Elements events
 174:// Enable/Disable Row filters
 175:privatevoid UltraCheckEditorRowFilteringCheckedChanged(object sender, EventArgs e)
 176:         {
 177:             ultraGrid1.DisplayLayout.Override.AllowRowFiltering =
 178:                 ultraGrid1.DisplayLayout.Override.AllowRowFiltering != DefaultableBoolean.True
 179:                 ? DefaultableBoolean.True
 180:                 : DefaultableBoolean.False;
 181:         }
 182:  
 183:  
 184:// Enable/Desable Fixed header indicator
 185:privatevoid UltraCheckEditorEnableFixedHeaderCheckedChanged(object sender, EventArgs e)
 186:         {
 187:             ultraGrid1.DisplayLayout.UseFixedHeaders =
 188:                 ultraGrid1.DisplayLayout.UseFixedHeaders != true;
 189:         }
 190:  
 191:  
 192:// Enable/Desable Row selectors
 193:privatevoid UltraCheckEditorEnableRowSelectorsCheckedChanged(object sender, EventArgs e)
 194:         {
 195:             ultraGrid1.DisplayLayout.Bands[0].Override.RowSelectors =
 196:                 ultraGrid1.DisplayLayout.Bands[0].Override.RowSelectors != DefaultableBoolean.Default
 197:                     ? DefaultableBoolean.Default
 198:                     : DefaultableBoolean.False;
 199:         }
 200:  
 201:  
 202:// Enable/Desable header CheckBox
 203:privatevoid UltraCheckEditorEnableHeaderCheckBoxCheckedChanged(object sender, EventArgs e)
 204:         {
 205:             ultraGrid1.DisplayLayout.Override.HeaderCheckBoxVisibility =
 206:                 ultraGrid1.DisplayLayout.Override.HeaderCheckBoxVisibility != HeaderCheckBoxVisibility.Always
 207:                     ? HeaderCheckBoxVisibility.Always
 208:                     : HeaderCheckBoxVisibility.Default;
 209:         }
 210:  
 211:  
 212:// Enable/Desable Filter Operator on the FilterRow.
 213:privatevoid UltraCheckEditorEnableFilterOperatorCheckedChanged(object sender, EventArgs e)
 214:         {
 215:             ultraGrid1.DisplayLayout.Override.FilterUIType =
 216:                ultraGrid1.DisplayLayout.Override.FilterUIType != FilterUIType.FilterRow
 217:                    ? FilterUIType.FilterRow
 218:                    : FilterUIType.Default;
 219:         }
 220:  
 221:  
 222:// Enable/Desable Column chooser
 223:privatevoid UltraCheckEditorEnableColumnChooserCheckedChanged(object sender, EventArgs e)
 224:         {
 225:             ultraGrid1.DisplayLayout.Override.RowSelectorHeaderStyle =
 226:                 ultraGrid1.DisplayLayout.Override.RowSelectorHeaderStyle != RowSelectorHeaderStyle.ColumnChooserButton
 227:                     ? RowSelectorHeaderStyle.ColumnChooserButton
 228:                     : RowSelectorHeaderStyle.Default;
 229:         }
 230:  
 231:  
 232:// Enable/Desable column Swapping
 233:privatevoid UltraCheckEditorEnableColumnSwappingCheckedChanged(object sender, EventArgs e)
 234:         {
 235:             ultraGrid1.DisplayLayout.Override.AllowColSwapping =
 236:                 ultraGrid1.DisplayLayout.Override.AllowColSwapping != AllowColSwapping.WithinBand
 237:                     ? AllowColSwapping.WithinBand
 238:                     : AllowColSwapping.Default;
 239:         }
 240:  
 241:  
 242:// Enable/Desable Row expansion indicator.
 243:privatevoid UltraCheckEditorExpansionIndicatorCheckedChanged(object sender, EventArgs e)
 244:         {
 245:             ultraGrid1.DisplayLayout.Override.ExpansionIndicator =
 246:                 ultraGrid1.DisplayLayout.Override.ExpansionIndicator != ShowExpansionIndicator.Always
 247:                     ? ShowExpansionIndicator.Always
 248:                     : ShowExpansionIndicator.Never;
 249:         }
 250:  
 251:  
 252:// Enable/Desable Row selector edit template
 253:privatevoid UltraCheckEditorRowSelectorEditTemplateCheckedChanged(object sender, EventArgs e)
 254:         {
 255:             ultraGrid1.DisplayLayout.Override.RowEditTemplateUIType =
 256:                 ultraGrid1.DisplayLayout.Override.RowEditTemplateUIType != RowEditTemplateUIType.RowSelectorImage
 257:                     ? RowEditTemplateUIType.RowSelectorImage
 258:                     : RowEditTemplateUIType.Default;
 259:         }
 260:  
 261:  
 262:// Switch to CardView
 263:privatevoid UltraCheckEditorSwitchToCardViewCheckedChanged(object sender, EventArgs e)
 264:         {
 265:             ultraGrid1.DisplayLayout.Bands[0].CardView = !ultraGrid1.DisplayLayout.Bands[0].CardView;
 266:         }
 267:  
 268:  
 269:// Select an item for FixedRowIndicator from the ComboBox.
 270:// if the FixedRowIndicator = "Button" it will appear on the row selector.
 271:privatevoid UltraComboEditorFixedRowIndicatorValueChanged(object sender, EventArgs e)
 272:         {
 273:             var cb = ultraComboEditor_FixedRowIndicator;
 274:if (cb == null || cb.SelectedItem == null) return;
 275:  
 276:// Hint: Use DataValue instead of DataText if you are retrieving an item, because DataText gets localized.
 277:             ultraGrid1.DisplayLayout.Override.FixedRowIndicator = (FixedRowIndicator)cb.SelectedIndex;
 278:         }
 279:  
 280:  
 281:// Select CardView style
 282:privatevoid UltraComboEditorSelectCardViewStyleValueChanged(object sender, EventArgs e)
 283:         {
 284:             var cb2 = ultraComboEditor_SelectCardViewStyle;
 285:if (cb2 == null) return;
 286:  
 287:             ultraGrid1.DisplayLayout.Bands[0].CardSettings.Style = (CardStyle)cb2.SelectedIndex;
 288:         }
 289:  
 290:  
 291:// Enamble/Desable Row summary button
 292:privatevoid UltraComboEditorEnableSummaryValueChanged(object sender, EventArgs e)
 293:         {
 294:             var cb3 = ultraComboEditor_EnableSummary;
 295:if (cb3 == null) return;
 296:  
 297:             ultraGrid1.DisplayLayout.Override.AllowRowSummaries = (AllowRowSummaries)cb3.SelectedIndex;
 298:         }
 299:  
 300:#region BtnEnableTouchClick
 301:privatevoid BtnEnableTouchClick(object sender, EventArgs e)
 302:         {
 303:             ultraTouchProvider1.Enabled = !ultraTouchProvider1.Enabled;
 304:             btnEnableTouch.Text = ultraTouchProvider1.Enabled ? Properties.Resources.Button_Disable_Touch : Properties.Resources.Button_Enable_Touch;
 305:  
 306:         } 
 307:#endregion
 308:     } 
 309:#endregion
 310: }

 

Touch WinListView And Tree

windows-forms-touch-experience-touch-winlistview-and-tree-en-us[1] 

 1:using System;
 2:using System.Drawing;
 3:using System.IO;
 4:using System.Windows.Forms;
 5:using Infragistics.Win.UltraWinListView;
 6:using Infragistics.Win.UltraWinTree;
 7:  
 8:namespace TouchEnabledListViewAndTree.CS
 9: {
 10:publicpartialclass TouchForm : Form
 11:     {
 12:#region Private Members
 13:privatereadonly ImageList _imageList1;
 14:privatereadonlystring _imagePath = Application.ExecutablePath + "\\..\\..\\..\\..\\Images\\";
 15:         private const string ImageSuffix = ".png"; 
 16:         #endregion
 17:  
 18:         #region Constructor
 19:         public TouchForm()
 20:         {
 21:             InitializeComponent();
 22:             _imageList1 = new ImageList();
 23:         } 
 24:         #endregion
 25:  
 26:         #region Public Methods
 27:  
 28:         #region PopulateWinList
 29:         // Populate WinListView with local directory and files
 30:         public void PopulateWinList()
 31:         {
 32:             // Add some UltraListViewSubItemColumns to the control's SubItemColumns collection 
 33:             // to represent the file type, and date modified
 34:             UltraListViewSubItemColumn colFileType = ultraListView1.SubItemColumns.Add(Properties.Resources.UltraListView_FileType);
 35:             UltraListViewSubItemColumn colDateModified = ultraListView1.SubItemColumns.Add(Properties.Resources.UltraListView_DateModified);
 36:  
 37:  
 38:             // FileType...
 39:             // Set the DataType property to string
 40:             colFileType.DataType = typeof(string);
 41:  
 42:  
 43:             // Set the Text property to "Type"
 44:             colFileType.Text = Properties.Resources.UltraListView_Type;
 45:  
 46:  
 47:             // DateModified...
 48:             // Set the DataType property to DateTime
 49:             colDateModified.DataType = typeof(DateTime);
 50:  
 51:  
 52:             // Set the Text property to "Date Modified"
 53:             colDateModified.Text = Properties.Resources.UltraListView_DateModified;
 54:  
 55:  
 56:             // Set the Format property so that we display the short representation of 
 57:             // the date and time, appropriate for the current culture
 58:             var shortDateFormat = System.Globalization.CultureInfo.CurrentCulture.DateTimeFormat.ShortDatePattern;
 59:             var shortTimeFormat = System.Globalization.CultureInfo.CurrentCulture.DateTimeFormat.ShortTimePattern;
 60:             colDateModified.Format = string.Format("{0} {1}", shortDateFormat, shortTimeFormat);
 61:  
 62:  
 63:             // MainColumn...
 64:             // Set the DataType to string
 65:             ultraListView1.MainColumn.DataType = typeof(string);
 66:  
 67:  
 68:             // Set the Text property to "Name"
 69:             ultraListView1.MainColumn.Text = Properties.Resources.UltraListView_Name;
 70:  
 71:  
 72:             // Add an appearance for the folder images, assigning to the folder items' Appearance
 73:             Infragistics.Win.Appearance appearance = ultraListView1.Appearances.Add(Properties.Resources.UltraListView_Folder);
 74:  
 75:             if (appearance != null)
 76:             {
 77:                 appearance.Image = new Bitmap(_imagePath + "Folder" + ImageSuffix);
 78:             }
 79:  
 80:             // Get a DirectoryInfo object that represents the C drive of the local machine
 81:             var cDriveInfo = new DirectoryInfo("C:\\");
 82:  
 83:  
 84:             // Get the directories and files
 85:             DirectoryInfo[] directories = cDriveInfo.GetDirectories();
 86:             FileInfo[] files = cDriveInfo.GetFiles();
 87:  
 88:  
 89:             // Iterate the directories and add an item for each one
 90:             for (int i = 0; i 
 91:             {
 92:                 DirectoryInfo directoryInfo = directories[i];
 93:  
 94:                 UltraListViewItem item = ultraListView1.Items.Add(directoryInfo.FullName, directoryInfo.Name);
 95:                 item.SubItems["FileType"].Value = Properties.Resources.UltraListView_File_Folder;
 96:                 item.SubItems["DateModified"].Value = directoryInfo.LastWriteTime;
 97:                 item.Appearance = ultraListView1.Appearances[Properties.Resources.UltraListView_Folder];
 98:             }
 99:  
 100:             // Iterate the files and add an item for each one
 101:             for (int i = 0; i 
 102:             {
 103:                 FileInfo fileInfo = files[i];
 104:  
 105:                 UltraListViewItem item = ultraListView1.Items.Add(fileInfo.FullName, fileInfo.Name);
 106:                 item.SubItems["FileType"].Value = Properties.Resources.UltraListView_File;
 107:                 item.SubItems["DateModified"].Value = fileInfo.LastWriteTime;
 108:  
 109:// Check to see if the image collection contains an image for this extension, using the extension as a key.
 110:if (!_imageList1.Images.ContainsKey(fileInfo.Extension))
 111:                 {
 112:// Set an icon for the file.
 113:                     var iconForFile = Icon.ExtractAssociatedIcon(fileInfo.FullName);
 114:  
 115:if (iconForFile != null)
 116:                         _imageList1.Images.Add(fileInfo.Extension, iconForFile);
 117:                 }
 118:                 _imageList1.ImageSize = new Size(256, 256);
 119:                 item.Appearance.Image = _imageList1.Images[fileInfo.Extension];
 120:             }
 121:             ultraListView1.EndUpdate();
 122:         }
 123:#endregion
 124:  
 125:#endregion
 126:  
 127:#region Events
 128:  
 129:#region TouchFormLoad
 130:privatevoid TouchFormLoad(object sender, EventArgs e)
 131:         {
 132:             PopulateWinList();
 133:  
 134:// Data Bind.
 135:             ultraTree1.DataSource = new Library().Categories;
 136:  
 137:// Initialize the ComboEditors with default display values.
 138:             UltraComboEditor_UltraTreeViewStyle.SelectedIndex = 4;
 139:             UltraComboEditor_UltraTreeNodeStyle.SelectedIndex = 4;
 140:             UltraComboEditor_UltraListViewStyle.SelectedIndex = 1;
 141:         }
 142:#endregion
 143:  
 144:#region BtnEnableTouchClick
 145:privatevoid BtnEnableTouchClick(object sender, EventArgs e)
 146:         {
 147:             ultraTouchProvider1.Enabled = !ultraTouchProvider1.Enabled;
 148:             btnEnableTouch.Text = ultraTouchProvider1.Enabled ? Properties.Resources.Button_Disable_Touch : Properties.Resources.Button_Enable_Touch;
 149:         }
 150:#endregion
 151:  
 152:#region UltraComboEditorUltraListViewStyleValueChanged
 153:// Set UltraListView style
 154:privatevoid UltraComboEditorUltraListViewStyleValueChanged(object sender, EventArgs e)
 155:         {
 156:             var cb = UltraComboEditor_UltraListViewStyle;
 157:if (cb == null || cb.SelectedItem == null)
 158:return;
 159:             ultraListView1.View = (UltraListViewStyle)cb.SelectedIndex;
 160:         }
 161:#endregion
 162:  
 163:#region UltraCheckEditorCheckedChanged
 164:// Enable Checkboxes for UltraListView (Only with Details or List view)
 165:privatevoid UltraCheckEditorCheckedChanged(object sender, EventArgs e)
 166:         {
 167:if (UltraCheckEditor_EnableCheckboxes.Checked)
 168:             {
 169:                 ultraListView1.ViewSettingsDetails.CheckBoxStyle = CheckBoxStyle.CheckBox;
 170:                 ultraListView1.ViewSettingsList.CheckBoxStyle = CheckBoxStyle.CheckBox;
 171:             }
 172:else
 173:             {
 174:                 ultraListView1.ViewSettingsDetails.CheckBoxStyle = CheckBoxStyle.None;
 175:                 ultraListView1.ViewSettingsList.CheckBoxStyle = CheckBoxStyle.None;
 176:             }
 177:         }
 178:#endregion
 179:  
 180:#region UltraComboEditorUltraTreeNodeStyleValueChanged
 181:// Set UltraTree Node style (Only with Standard View)
 182:privatevoid UltraComboEditorUltraTreeNodeStyleValueChanged(object sender, EventArgs e)
 183:         {
 184:             var cb = UltraComboEditor_UltraTreeNodeStyle;
 185:if (cb == null || cb.SelectedItem == null)
 186:return;
 187:             ultraTree1.Override.NodeStyle = (NodeStyle)cb.SelectedIndex;
 188:         }
 189:#endregion
 190:  
 191:#region UltraComboEditorUltraTreeViewStyleValueChanged
 192:// Set UltraTree View style
 193:privatevoid UltraComboEditorUltraTreeViewStyleValueChanged(object sender, EventArgs e)
 194:         {
 195:             var cb = UltraComboEditor_UltraTreeViewStyle;
 196:if (cb == null || cb.SelectedItem == null)
 197:return;
 198:             ultraTree1.ViewStyle = (ViewStyle)cb.SelectedIndex;
 199:         }
 200:#endregion
 201:  
 202:#endregion
 203:     }
 204: }

 

To play around with the Infragistics Windows Forms touch enabled applications on your own, be sure to get Infragistics Ultimate and see the chart in action in our latest sample application by clicking the banner below!


Mobile browsers: State of the industry

0
0

Can you remember the first time you browsed the internet from a mobile phone? Pages seemed to take days to load, video was an impossibility and even basic interaction - filling forms or copying text - was a real struggle. Now, however, we use the internet so often from our smartphones and tablets, we easily forget just how far the industry has come in a few short years. Today’s mobile web browsers are faster, smoother and more intuitive than ever and innovation on these tools has gone at a blistering rate.

People use mobile devices to browse the web at different times and in different ways to how they do on laptops and desktops. For example, in terms of conversion rates on retail websites, people tend to research products from phones but buy from their laptops. Mobile devices have become an intimate part of our lives and the challenge for developers is to build websites which correspond with the kinds of experiences users expect.

Fortunately, there’s a whole range of tools available which help developers build and modify websites and which capitalize on the features of different mobile browsers. Innovation on mobile web browsers is constantly evolving, so in this post we’ll be taking a snapshot look at the state of play with the major players in the industry.

The innovators

Perhaps the most exciting thing about mobile web browsers is the constant innovation visible in the industry. While the principal operating systems (iOS, Windows and Android) are all bundled with their own browsers which have done a lot to push things forward, there are many other browsers which are also contributing to how we interact with websites from our mobiles. These alternative browsers - think Dolphin, Firefox or Opera (to name but a few) - are less constrained and are therefore more able to contribute amazing ideas, add-ons and features too (see some alternatives here).

The Android Web Browser

Google have a slightly confusing  approach to the web browsers they release on different devices. The Android Web Browser is the default browser on many devices, although on some more recent releases it’s Chrome which comes bundled. Either way, these two are now much the same and offer almost the exact same functionality.

Google’s mobile web browsers are some of the most popular and widely used on the planet. Depending on whose statistics you believe, up to 40% of mobile web usage takes place on Android devices. Now, Google (as with the other major providers) obviously have an advantage here - they can count on user’s tendency to use the pre-installed browsers on their phones. Nonetheless, the browser is pretty impressive and some of its finest features include:

 

  • Sleek page transitions
  • Impressive tab system
  • The ability to sync with your Google accounts
  • The possibility of sharing data between different devices
  • Add-ons and a fair amount of customizability (around security, data tracking and so on)
  • Reduce data usage with Chrome’s Data Saver

 

Safari on iOS

When Apple released the iPhone back in 2007 they bundled Safari, their pre-existing web browser. Safari has undergone a big evolution since it first came into existence in the early noughties, and Safari 8, released in 2014 is jam packed with improvements and new features.

While it’s possible to use other browsers on your iPhone or iPad, the appeal of using Safari is its integration with the Apple universe. For instance, you can set it to automatically sync with your iCloud, so every picture, reading list, open tab - or whatever else - is synced between your devices. Safari also has some of the best security features, offering Private Browsing, blocking third party cookies and implementing Do Not track as standard.

What’s great in the latest release?

 

  • WebGL - so developers can build 3D experiences
  • HTML5 premium video as standard
  • Increased speed and efficiency
  • Better than ever iCloud synchronization
  • Improved design and feel

 

Internet Explorer for Mobile

As with its competitors, Windows Mobile web browser has similarly undergone a long series of developments, but with Internet Explorer 11, its latest release, it really is pushing boundaries. And, with the upcoming release of Spartan, things are only going to get better. Internet Explorer is hands down the fastest mobile web browser (although most users will barely notice the difference) and, as with Safari, integrates so well with other Windows products it’s tempting to just stick with it as default.

Some of the features we love about the browser include:

 

  • Great UI - you can swipe left and right to reach previous and next pages
  • You can pin favourite pages to your phone’s start screen
  • HTML5 video player as standard
  • Open tabs are synced with your other Windows devices
  • You can have an unlimited number of tabs open

 

Browse ahead

There’s so much innovation going on with mobile web browsers that it’s easy to forget how far we’ve come in so little time. It’s an awesome time to be building websites and the possibilities offered by modern browsers - inline video, greater security, 3D and synchronization open up some incredible opportunities. Now it’s up to developers to decide what to do with them.

A lean UX conference

0
0

The 2015 ux(bar)camp in Copenhagen through the eyes of an Infragistics employee

clip_image003

The #uxcampcph logo. Image attributed to: http://uxcampcph.org/Uploads/UXCampCPH_HVID_transparant.png

 

What is lean and how does it find its way in our daily life?

Lean manufacturing, lean software development and a lean methodology from a book called “The Lean Startup”… it seems as if “lean” is the fancy new buzzword for modern processes. But what specifically does this concept stand for? To illustrate the differences between a traditional model and the lean one, I will first discuss two UIs that solve the same problem but take different approaches. Then I will share my experiences from the UX Camp in Copenhagen last weekend, which exemplifies how a community event can also be designed in a “lean” way.

 

Yahoo and Google

Imagine you had a time machine and travelled 20 years back in time. The Internet was still just a baby and there were only a few visionaries who, unconventionally, believed in it. For many people, AOL was the browser and the Internet, as it was, a catalogue of online information. And at the same time, Yahoo was still a toddler and it would take another 3 years before Google was born. But what is “the common denominator” for the latter two companies? It is the problem of finding necessary information online that also turned out to be a call for interaction paradigm shift. A shift that resulted in the inception of the search engine – core business of both Yahoo and Google back in the day. Since the two appeared in the market, many products have been added to their portfolios: e-mail, news articles, videos, stock charts, weather information, and sport results. One can easily bet that there will be many more to come, but what do we encounter now upon visiting the two websites? Yahoo has it all on their homepage, and Google is not much more than a logo, a text field and a couple of buttons.

clip_image006clip_image008

Yahoo home page (left) and Google home page (right) today.
Images attributed to: https://www.yahoo.com/ and https://www.google.com/

 

Now let’s talk lean – it is all about flexibility, about how rapidly one can react to changes, about how quickly one can test a hypothesis and get real data to act upon. Imagine that you had to add that new and considered-to-be-cool feature. It would take a tremendous amount of time even to reach the point of testing its layout, for example, on the Yahoo home page because there is so much other stuff to consider. What if we want to do the same with Google? Well, just add an icon to the list of options in the popover, shown upon clicking on “apps” – that icon consisting of 9 gray squares in the top right. So, adding a container on a cluttered homepage vs. adding an icon to a popover list. Which of the two would require less effort to prototype and test? Which of the two requires less stuff to consider? Which of the two can lead to a well-informed design decision faster? These questions lead to the answer of what we are really interested in: Which UI is more “lean”? Lean is not about coming to the optimal solution, lean is about finding a good-enough, informed solution fast!

The lean conference

Strangely enough, this same concept can be applied, not only to software design and development processes, but to very “structured” and “offline” things, such as community events. UX Camp CPH (CPH stands for Copenhagen) was my first forum of its kind and will definitely not be the last. Let me be more specific about what is found at the core of such a (bar)camp forum and makes it so different. As simple as it may seem, it is the following: there are no speakers, everybody is a speaker. Of course, this is true to some extent as there were a few invited speakers to set the UX mood on Friday night and a very practical Saturday morning talk to break the ice (details about the talks will follow in another blog later this week). The core, however, was the pitching session on Saturday that was to define what the rest of the day might look like to an attendee. Everyone was given the opportunity to briefly present a UX topic about which they are passionate and willing to share with the others. Then voting takes place and in less than an hour the whole schedule is arranged on a whiteboard before the eyes of everyone. In the case of uxcampcph each person had the option to choose from 7 topics, discussed in different rooms at the same time and this whole thing happened 4 times throughout the day. This seemingly ad-hoc schedule assembling is exactly what makes uxcampcphlean. There is no separate call for speakers, discussions about whether a topic is appropriate, speaker cancellations or last minute schedule changes. Everything happens organically and is driven by the interest of the audience for a given topic or speaker. Whether the speaker is presenting a case study, a methodology, a crazy design or whatever has been crossing his or her mind lately, decisions are left to the audience - the very same crowd that will later attend the talk. If that is not a lean event, then I cannot really imagine what would be.

2015-04-25 12.39.46

The schedule. Image attributed to the author.

 

After all talks were over, the late Saturday afternoon offered a closing keynote that felt like the icing on the cake. Jeff Gothelf himself talked about lean UX, about design in the agile world and his observations that lead to writing that famous smashing magazine article that later inspired the book “Lean UX: Getting Out Of The Deliverables Business”. I would like to thank Jeff personally for his amazing keynote. Since most of what is read in a book is forgotten a week later, putting some of it into practice helps me retain more of it. But listening to the author talk about his book in person is definitely a memory that will not soon fade despite the “bar” part that followed. Oh yeah, I forgot to mention that the whole experience was accompanied by a decent amount of tasty Danish beer after the official closing.

Thank you UX Camp CPH for the amazing weekend. And to the readers – expect another blog on the topics presented during the conference very soon.

Version 5 released, and introducing indigodesigned.com!

0
0

At first glance, it may seem that not a lot changed with the release of version 5. In fact, it’s quite the opposite! Let me walk you through some key highlights not discussed elsewhere.

Introducing indigodesigned.com

Indigodesigned.com is now live! Before v5, when you shared a prototype on Infragistics server, you received a share URL which you can send to anyone. Your users will use this link to view prototypes on any device using the web browser. Sharing on Infragistics’s server is still the fastest, hassle-free and secure way to let others view your prototype.

With v5, we are launching indigodesigned.com. Think of indigodesigned.com as name we have given to our prototype hosting/sharing service instead of calling it Infragistics server. And to be fair, indigodesigned.com is so much more than just hosting.

Indigodesigned

This also means that you do not need to fire up the application to manage your private shares. You can do this by visiting indigodesigned.com using your web browser.

Anonymous, Private & Community Shares

The prototypes you share without signing in are still private, but we’ll refer to them as anonymous shares. Now you can also sign in with your Infragistics user name and password before sharing and create what we’ll call private shares. And when you sign-in on indigodesigned.com, you will be able to view these under My Shares.

To support this, the share dialog in Indigo Studio has changed so you can sign in. In addition to this, you can add metadata to each of your shares by adding a description and tags. This will allow your viewers to read the description for your prototype before they get click-happy :D! Learn more about sharing your prototypes.

New Share Dialog

By choosing to create a private share, you get a private share URL to access the prototype PLUS the following:

  • View & Manage your shares from any device
  • Organize your shares with tags and Collections
  • Edit prototype details on indigodesigned.com
  • Showcase your work in the indigodesigned community, and get kudos!

Learn more about indigodesigned.com

You can switch any private share into a community share by editing the privacy setting for the share. And you can switch back and forth as frequently as you like. This allows you to share any cool prototype, library or tips you have with the indigodesigned community. Let’s work together to make our prototyping experiences more productive!

Check out what other users have contributed to the indigodesigned community! It's your turn now to pay it forward ;).

privacy settings

Claiming Anonymous Shares

If you are a continuing user of Indigo Studio, you will notice that existing shares are not visible under your shares on indigodesigned.com.

Conceptually, indigodesigned.com offers three levels of sharing/hosting:

  • Anonymous shares 
  • Private(Authenticated) shares 
  • Community shares

Before v5, we had no way of knowing who shared what on the Infragistics server, unless you told us. The only known share history is available on your computer, which you can access via the manage shares option in your project home toolbar.

Version 5 is the first version to support authentication when sharing your prototype. Once you are signed in with your Infragistics username inside the application, you can claim share from your share history to make it a private share. Shares you claim as yours will start showing up under my share on indigodesigned.com.

Some changes you may notice:

  • Share URLs now has the following format: https://indigodesigned.com/share/ID. Older URLs will be automatically redirected to newer ones. You will not need to resend the link to your viewers/stakeholders. 
  • Anyone accessing the share URL will see a landing page showing the prototype thumbnail and description.

PRO-TIP: To skip the landing page or to anonymize your share, insert run/ ahead of the share ID, like so: https://indigodesigned.com/share/run/ID

Sharing (and importing) screenpart libraries

While indigodesigned.com is the place where your prototypes are showcased and managed, it was originally conceived as an easier way to share screenpart libraries!

Screenpart libraries, as you may know, are custom UI libraries that you create in Indigo Studio for sharing across screens in your project. A screenpart is any customized UI element or a collection of UI elements (e.g., dialogs) that you can save to your screenparts toolbox for reuse.

Not familiar with screenparts? Read about it here or watch a video tutorial.

In version 5, we have made it easier to reuse screenparts across projects and not just screens. And this is achieved using screenpart libraries approach (filename.library).

There are two parts to the library story: 

  1. Sharing screenpart library online/offline 
  2. Importing and using screenpart libraries

1. Sharing libraries online/offline

Say you created screenparts, and saved them in your project (e.g., myFirstProject). Every project in Indigo Studio is saved as a folder on your file system. This project folder also contains screens and storyboards you created. New screenparts, by default, are saved in a subfolder in your project folder (e.g., myFirstProject\screenparts\).

Just like you select screens from the project home view to share as a prototype, you can do the same with screenparts. Using the share dialog you can either share this on indigodesigned.com or offline on your desktop. Selecting the share on desktop option will let you generate a filename.library file, containing all the selected screenparts.

Sharing library from Project Home

2. Importing and using libraries

When you start a new project (e.g., mySecondProject), you can now import the filename.libary into this new project. Simply find and open the .library file from Indigo Studio, or use the import screenpart libraries action available in the screenparts toolbox.

import library

Any imported library file is first added to a common location, and can be viewed under, drumroll, libraries available for import in the screenparts toolbox. This common location is accessible to any new/existing Indigo Studio Project. Importing from this location will automatically copy the new screenparts into your project in a subfolder (e.g., mySecondProject\screenparts ew screenparts), keeping it clean and separate.

You can change the default location of this global/common folder where all the .library files are saved. This is can be done for each Indigo Studio installation.

The process is the same for importing library files downloaded from indigodesigned.com. And very soon you will see the option to download from community right within the Indigo Studio app. Choosing to share it on indigodesigned.com will let you send your .library file to anyone who can access the web. In addition to that, one can preview/run the individual screenparts contained in a library before downloading it.

If you still have questions about this feature, read our help topic on managing screenpart libraries.

How to get this Update?

Here’s how you can update the version of Indigo Studio installed on your machine:

  • If you have the option to automatically check for updates on startup checked, you should see a dialog box pop up when you launch Indigo. Simply click update, and Indigo Studio will do the rest. This is the easier approach.
  • If for some reason you chose not to automatically check for updates, go to MENU > HELP & ABOUT and use the “CHECK FOR UPDATES” option.

Checking for Updates

About Indigo Studio for Interaction Prototyping

Don’t have Indigo Studio? Download a free 30-day trial which will let you try all of the prototyping goodness!

Download Indigo Studio

Looking to suggest improvements and new ideas for Indigo Studio?

Submit a new idea

If for some reason you are having trouble with Indigo Studio, check out our help topics, forums or contact support.

Get Support

Follow us on Twitter @indigodesigned

View Release Notes

Converting WinForms to WPF: Should you consider it?

0
0

WinForms has long been a popular way to develop form and GUI based applications, generally for Windows based devices. Part of the .NET framework, and originally seen as a replacement for Microsoft Foundation Class Library (MFC), WinForms applications are ‘event driven’. That is they sit and wait for a user to interact with them, before springing into action and reacting to this input.

Whilst still a useful technology for many (we offer a whole range of useful and popular controls) WinForms is officially a technology in ‘maintenance mode’. According to Microsoft, the product is no longer subject to active development, won’t be seeing any new features in the future, but will benefit from bug fixes.

With that in mind, what is the argument for converting a WinForms app to a more modern technology like Windows Presentation Foundation (WPF)? In this post we will take a look at this topic, weighing up the various options and pros and cons.

Windows Presentation Foundation

Windows Presentation Foundation is a different API for building GUIs. Separate to WinForms, but also included in the .NET Framework, it is based on DirectX and uses a language called XAML to describe its components and elements. Many developers often ask the question: “Can I easily convert my WinForms app?” Let us look at some useful answer and pointers:

1. A chance to improve your code

After deciding to ‘convert’ your WinForms app to WPF, take a step back and decide if the best approach isn’t to simply rewrite your code from scratch. Undoubtedly you will learn a lot during the process, and the end result will most likely be altogether better code. Switching from WinForms to WPF does involve a change in mindset, this article looks at how your approach should differ. WPF is at its core very different to WinForms, understanding the basics of WPF before you start to migrate any code is a vital step.

2. Converting C#.NET WinForms designer code

If you are looking for a more ‘automated’ approach, there are utilities that will convert C#.NET designer code to XAML. This one is good example, though we do advise have a good manual check over the code as well. This CodePlex project is also capable of handling basic conversion, taking basic WinForms Form Controls and even carrying over event handling code. Beware the project hasn’t been updated for a number of years. A more up to date option can be found here, and this tool does come with support for a number of different controls.

3. Hosting WinForms inside a WPF application

Rather than converting an entire application, it is possible to reuse WinForms code by hosting controls inside a WPF application. Microsoft offers a very detailed walkthrough on hosting WinForms composite controls inside a WPF application.

4. Validating the results

If you are new to WPF, or converting/porting code over from WinForms, then it is a good idea to double check the final results. Some useful tools to do this include:

 

  • Last updated a few years ago, Snoop is however still a useful way to visually debug WPF apps.
  • Shazzam helps to testing WPF pixel shaders
  • Any good .NET developer will know about Reflector
  • Microsoft Blend started life as a stand-alone user interface tool, but is now part of Visual Studio. Either way it is an interesting way of designing WPF apps, and can be a useful aid for those moving from WinForms.
  • The WPF Performance Suite helps to analyze the behaviour of WPF apps, and provides a means to implement improvements. Useful for those starting out with WPF or refactoring code form WinForms apps.

 

Multiple options

As experienced developers will know, the .NET framework offers a number of methods and solutions to solving any given problem. When it comes to GUI applications WinForms and WPF are both still very much valid choices, and as we have seen in this post there are means to convert between the two approaches. Whatever the route taken, Infragistics offers a range of pre-built UI components to help make the final results even more impressive.

How does your company secure its mobile devices?

0
0

Mobile Device Security

Even ten years ago, the idea that employees would be bringing their own personal IT devices to work then accessing and editing company information from them would have seemed incredible. Of course, technology has moved on rapidly in the last few years and BYOD (Bring Your Own Device) is a growing trend. In fact, research by Gartner suggests that by 2017 half of employers will require employees to supply their own device for at least some work activities.

BYOD is a fascinating proposition. On one hand, it’s purported to bring an array of benefits to the workplace - everything from more satisfied employees and reduced IT costs to increased out of work engagement and lessened stress on information systems. However, it also comes under fire for placing too much responsibility on workers to supply their own high quality devices (although BYOD programs normally include some payment to workers), the risk of intrusion in employees’ personal lives and, of course, perceived security issues.

A worldwide phenomenon, BYOD is catching on everywhere as companies come to realize that a well-managed BYOD policy is probably no less risky than supplying employees with the company’s own devices and desktops. Nonetheless, the risks are real and many IT managers will feel torn between taking the leap into BYOD and sticking with what they know and trust. Whether your company has already initiated a BYOD plan and you’re working out how to keep data safe on devices, or if you supply colleagues with company-owned hardware for when they leave the office, SharePlus from Infragistics helps overcome this dilemma.

Plan, train and test

When taking a big step such as moving to a BYOD model, it’s essential to prepare your IT department and the organization in general for the change. This includes:

  • Planning: develop a roadmap for how the BYOD policy will be deployed. Decide when, how and where it will be done, prepare for obstacles and do your research into the most appropriate solutions for your organization.
  • Training: For employees to really understand how the new policy will work, they’ll need significant training. By giving them the necessary information about how to access and use the new apps on their phones and devices you can be more sure that security risks be avoided.
  • Test: To ensure the roll out into your organization goes smoothly, begin by testing on a small number of ‘Guinea Pigs’. You’ll then be able to spot and smooth out any hitches before global deployment.

 

Mobile access to your portal

By far the most popular and powerful Enterprise IT platform, workers around the world are familiar with SharePoint and its many impressive features. However, despite enormous file storage space and social, collaborative and communication capabilities, the platform continues to be problematic for viewing from mobile devices.

Given the opportunities that mobile technology offers for on-the-go working, a tool such as SharePlus is therefore of real benefit to modern organizations. It allows real time collaboration from most major devices and offline document editing from anywhere. With an intuitive and easy to use interface, it really stands out thanks to its comprehensive security features. Whether it’s for BYOD or simply protecting your company’s own devices when they leave the office, SharePlus has security covered.

  • Data storage: the greatest fear of any IT manager is that their company’s private data is jeopardized and valuable information accessed by malicious individuals outside the business. SharePlus responds to this concern by guaranteeing Data Storage security by allowing a secure data wipe of any company data which is held on a lost or stolen device.
  • Channel communication security: The risk of allowing colleagues to access your data through an external device is that they may (intentionally or otherwise) also be connected to another external network while connected to your company’s systems. SharePlus however, protects the connection between devices and your firm’s SharePoint solution however by employing a Virtual Private Network (VPN) and using a Secure Sockets Layer (SSL).
  • Authentication and authorization services: The first step in protecting company data is of course to set passwords. SharePlus includes numerous additional levels of security to ensure company data is well protected however, including authentication mechanisms which check the identity of visitors and client side certificates. With these additional layers of security, IT managers can feel confident that only the right people can see company data.
  • Enforcing business security: The beauty of SharePoint is that, through the use of views, administrators can decide who has access to private data. With SharePlus, this capability is extended and it’s possible to decide centrally what files and information can be seen from devices.

BYOD in security

BYOD is an increasingly common trend in modern businesses and offers great opportunities to engage employees and increase their workplace satisfaction. Nonetheless, there are considerable and understandable security concerns for IT Managers who fear information leaks or the threat of malware from employee devices for instance. SharePlus offers the possibility of tapping into this modern trend whilst also providing the peace of mind that business systems are protected.

Looking for a comprehensive and secure mobile SharePoint solution, which you can customize to your preferences? Look no further. Download our SharePlus free trial now and see the wonders it can do for your team's productivity!

SharePlus for SharePoint - Download for Android

Viewing all 2363 articles
Browse latest View live




Latest Images