Blog de Luis Dueñas dedicado a la difusión del Desarrollo en Microsoft .NET, Visual Studio, WinForms, WebForms, MVC, ASP .NET, jQuery, AJAX, HTML5, JavaScript, Móviles, etc. Encontrarás Libros, Demos, Artículos Técnicos, Entrenamiento.
Curso de Desarrollo de Aplicaciones Móviles Bajo Android
Comparto con ustedes el contenido del nuevo programa de capacitación que se estará brindando para todos los interesados en el desarrollo de aplicaciones nativas en Android.
Este curso será presencial en la ciudad de Lima, Perú y será impartido por el consultor Eduardo Monroy Husillos de nacionalidad española, quien cuenta con amplia experiencia en desarrollo bajo esta plataforma y con especialidad en Internet de las Cosas IoT.
Formación académica del expositor:
Maestría especialidad de electrónica industrial (Escuela de Ingenieros de Bilbao).
Postgrado en sistema de transmisión de datos, telecomunicaciones analógicas y digitales. (Escuela de Ingenieros de Bilbao)
Máster en programación en dispositivos móviles iOS. (Standford University)
Capacitación en programación en Android (Aula Mentor – Ministerio de Educación)
Sistemas de localización RFID Activa IP (Dusseldorf – Alemania)
Técnicas de localización mediante sensores Smartphone (Heathrow – Inglaterra)
Inserción, actualización y eliminación de registros
Consulta y recuperación de registros.
Ficheros (FileManager):
Lectura
Escritura
Edición
Borrado
Tratamiento de XML:
SAX
SAX simplificado
DOM
XMLPULL
Otras alternativas para leer y escribir XML
Notificaciones:
Toast
Barra de Estado
Diálogos
Snackbar
Acceso a Servicios Web:
SOAP
REST
Tareas en Segundo Plano:
Thread y AsyncTask
IntentService
Depuración de Código:
Logging
Sensores y Comunicaciones:
Botones
Acelerómetro
Bluetooth
Cámara
NFC
Firebase para Android
Base de datos en tiempo real (RealTime DataBase)
Notificaciones Push (OneSignal)
Publicación de Aplicación Google Play
Alta como desarrollador en google developer program.
Pasos para la publicación de una App
Marco Práctico:
A lo largo del curso se impartirá los conocimientos necesarios para que el alumno pueda crear su propia App. En este caso será la creación de aplicación de mensajería (SuperWhatsApp)
Bajo depósito en cuenta bancaria, máximo 3 días previo al inicio de cada mes (360.00 soles)
Banco: Interbank
Cuenta en moneda nacional: 637-3066861788
Código interbancario: 00363701306686178864
A nombre de: Edward Schwarz Moreno
DNI: 09564483
Contacto
Los interesados enviar un mail a Luis.duenash@gmail.com con los siguientes datos:
Asunto: Curso de Desarrollo de Aplicaciones Móviles Bajo Android
Contenido del correo:
Nombre completo
Lugar de trabajo o estudio
Ha sido ex-alumno (especificar PECI .NET, Web Developer, Talleres, Seminarios)
Registro
Sólo se considerará a los 25 primeros que envíen correo electrónico adjuntando el comprobante por el depósito realizado dado que la capacidad del lugar es limitada. La metodología del curso seguirá siendo la misma que se ha venido aplicando a los tallares de MVC-JavaScript.
No se entregará comprobante por el pago mensual y no se hará entrega de certificado de asistencia al curso. La capacitación está dirigida especialmente a la comunidad de alumnos que he venido entrenando a lo largo de estos últimos años, a los seguidores del Blog y al público en general que desee participar.
Capítulos:
Chapter 1 Welcome to Visual Basic 2015
Chapter 2 The Microsoft .NET Framework
Chapter 3 Writing Software
Chapter 4 Controlling the Flow
Chapter 5 Working with Data Structures
Chapter 6 Building Windows Applications
Chapter 7 Displaying Dialogs
Chapter 8 Creating Menus
Chapter 9 Debugging and Error Handling
Chapter 10 Building Objects
Chapter 11 Advanced Object-Oriented Techniques
Chapter 12 Accessing Data Using Structured Query Language
Chapter 13 Database Programming with SQL Server and ADO.NET
Chapter 14 ASP.NET
Chapter 15 Deploying Your Application
Chapter 16 Windows 8 Apps
Appendix Exercise Solutions
Titulo: C# 24-Hour Trainer (2nd Edition)
Autor: Rod Stephens
Editorial: Wrox
Nro Paginas: 597
Capítulos:
SECTION I THE VISUAL STUDIO IDE AND CONTROLS
LESSON 1 Getting Started with the Visual Studio IDE
LESSON 2 Creating Controls
LESSON 3 Making Controls Arrange Themselves
LESSON 4 Handling Events
LESSON 5 Making Menus
LESSON 6 Making Tool Strips and Status Strips
LESSON 7 Using RichTextBoxes
LESSON 8 Using Standard Dialogs
LESSON 9 Creating and Displaying New Forms
LESSON 10 Building Custom Dialogs
SECTION II VARIABLES AND CALCULATIONS
LESSON 11 Using Variables and Performing Calculations
LESSON 12 Debugging Code
LESSON 13 Understanding Scope
LESSON 14 Working with Strings
LESSON 15 Working with Dates and Times
LESSON 16 Using Arrays and Collections
LESSON 17 Using Enumerations and Structures
SECTION III PROGRAM STATEMENTS
LESSON 18 Making Choices
LESSON 19 Repeating Program Steps
LESSON 20 Reusing Code with Methods
LESSON 21 Handling Errors
LESSON 22 Preventing Bugs
SECTION IV CLASSES
LESSON 23 Defining Classes
LESSON 24 Initializing Objects
LESSON 25 Fine-Tuning Classes
LESSON 26 Overloading Operators
LESSON 27 Using Interfaces
LESSON 28 Making Generic Classes
SECTION V SYSTEM INTERACTIONST
LESSON 29 Using Files
LESSON 30 Printing
SECTION VI WINDOWS APPS
LESSON 31 Windows Store Apps
LESSON 32 Windows Phone Apps
SECTION VII SPECIALIZED TOPICS
LESSON 33 Localizing Programs
LESSON 34 Programming Databases, Part 1
LESSON 35 Programming Databases, Part 2
LESSON 36 LINQ to Objects
LESSON 37 LINQ to SQL
Titulo: Ionic in Action
Autor: Jeremy Wilken
Editorial: Manning
Nro Paginas: 282
Capítulos:
1. Introducing Ionic and hybrid apps
2. Setting up you computer to build apps
3. What you need to know about AngularJS
4. Ionic navigation and core components
5. Tabs, advanced lists, and form components
6. Weather app, using side menus, modals, action sheets, and ionScroll
7. Advanced techniques for professionals apps
8. Using Cordova plugins
9. Previewing, debugging, and automated testing
10. Building and publishing apps
Aumentar Funcionalidad en una Aplicación WinForms usando Reflection (Sin Recompilar)
El Problema de la Actualización de Aplicaciones
Cada vez que se crea una Aplicación Windows se distribuye el ejecutable en las diferentes PCs de los usuarios que van a usar la aplicación.
Solución Actual al Problema de la Actualización de Aplicaciones
Si deseamos realizar cambios, sobre todo aumentar nueva funcionalidad, existen 2 soluciones comunes:
1. Recuperar los fuentes (código fuente), aumentar la funcionalidad, recompilar y volver a distribuir.
Problema: Si no se tiene los fuentes, porque muchas veces se compra solo el ejecutable (por dismunir costos) no se podría usar esta técnica.
2. Ejecutar desde el Módulo Principal los demás Módulos, es decir una aplicación preparada para ejecutar cualquier exe (los módulos)
Problema: No hay un control interno de las ventanas de los módulos que se ejecuten, por ejemplo que aparezcan dentro del MDI Principal, se puedan organizar y sobre todo el intercambio de datos.
Solución Propuesta al Problema de la Actualización de Aplicaciones
Construir un Sistema Principal que pueda ejecutar cualquier módulo, ya sea una aplicación o una librería, para eso usaremos Reflection.
Las 3 tareas a realizar desde el menú principal del sistema serían:
1. Ejecutar formularios (clases) desde cualquier ensamblado
2. Ejecutar procesos (exe) como por ejemplo utilitarios del sistema
3. Ejecutar métodos (funciones públicas) de cualquier clase de cualquier ensamblado
Con esta aproximación, para aumentar nueva funcionalidad solo basta hacer 2 cosas:
1. Aumentar en tablas (en nuestro caso un archivo de texto) las nuevas opciones del menú
2. Copiar el o los archivos exe (módulos de procesos, usables también independientemente) y archivos dll (módulos de librerías, usables solo por el módulo principal u otras aplicaciones).
Componentes del Demo
Este demo tiene los siguientes componentes (archivos):
1. Menus.txt: Archivo de texto con las opciones del menú principal a cargar.
2. SistemaPrincipal.exe: La aplicación principal (WinForms) que tiene un MDI con el código que permite cargar los menús y a través de este abrir cualquier formulario, ejecutar procesos y ejecutar métodos.
3. ModuloProcesos.exe: Una aplicación WinForms que contiene 2 formularios que van a aumentarse al Sistema Principal. También puede ejecutarse por si sola y muestra un formulario con dos opciones.
4. ModuloReportes.dll: Una librería conteniendo 2 formularios y una clase Rutinas con un método.
Crear la Aplicación Windows Forms con el Sistema Principal
Abrir Visual Studio y crear una aplicación Windows Forms en C# llamada "SistemaPrincipal", cambiarle de nombre al formulario por "frmPrincipal", configurar su propiedad IsMdiContainer en true y realizar el diseño similar a la figura mostrada:
Agregar 4 formularios al proyecto (configurar su propiedad BackColor en Red), con los siguientes nombres:
- frmConProdCat.cs: Propiedad Text en "Consulta de Productos por Categoria"
- frmConProdProv.cs: Propiedad Text en "Consulta de Productos Proveedor"
- frmManCliente.cs: Propiedad Text en "Mantenimiento de Clientes"
- frmManEmpleado.cs: Propiedad Text en "Mantenimiento de Empleados"
Crear una Clase Entidad de Negocio para el Menú
Agregar una clase al proyecto llamada: "beMenu" y escribir el siguiente código:
using System;
namespace SistemaPrincipal
{
public class beMenu
{
public string IdMenu { get; set; }
public string Titulo { get; set; }
public string Ensamblado { get; set; }
public string Accion { get; set; }
public string IdPadre { get; set; }
}
}
Crear una Clase Agente de Servicio para el Menú
Agregar una clase al proyecto llamada: "saMenu" y escribir el siguiente código:
using System;
using System.Text;
using System.IO;
using System.Collections.Generic;
namespace SistemaPrincipal
{
public class saMenu
{
public List<beMenu> Listar(string NombreArchivo)
{
List<beMenu> lbeMenu = null;
if (File.Exists(NombreArchivo))
{
using (StreamReader sr = new StreamReader(NombreArchivo, Encoding.Default))
{
string[] menu;
lbeMenu = new List<beMenu>();
beMenu obeMenu;
while (!sr.EndOfStream)
{
menu = sr.ReadLine().Split(',');
obeMenu = new beMenu();
obeMenu.IdMenu = menu[0];
obeMenu.Titulo = menu[1];
obeMenu.Ensamblado = menu[2];
obeMenu.Accion = menu[3];
obeMenu.IdPadre = menu[4];
lbeMenu.Add(obeMenu);
}
}
}
return (lbeMenu);
}
}
}
Nota: Para los que no conocen la terminología distribuida, si la clase es de datos es da: DataAccess, pero si trabajamos con recursos que no son bases de datos, como archivos de texto, la clase es sa: ServiceAgents (Agentes de Servicio).
Crear una Clase Regla de Negocio para el Menú
Agregar una clase al proyecto llamada: "brMenu" y escribir el siguiente código:
using System;
using System.Collections.Generic;
namespace SistemaPrincipal
{
public class brMenu
{
public List<beMenu> Listar()
{
List<beMenu> lbeMenu = null;
saMenu osaMenu = new saMenu();
lbeMenu = osaMenu.Listar("Menus.txt");
return (lbeMenu);
}
}
}
Escribir Código para el Formulario frmPrincipal
using System;
using System.Diagnostics;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Reflection;
using System.IO;
namespace SistemaPrincipal
{
public partial class frmPrincipal : Form
{
List<beMenu> lbeMenu;
private void crearSubMenu(beMenu obeMenuPadre,ToolStripMenuItem mnuPadre)
{
List<beMenu> lbeMenuHijos =
lbeMenu.FindAll(x=>x.IdPadre.Equals(obeMenuPadre.IdMenu));
ToolStripMenuItem mnuHijo;
foreach (beMenu obeMenuHijo in lbeMenuHijos)
{
mnuHijo = new ToolStripMenuItem(obeMenuHijo.Titulo);
mnuHijo.Tag = String.Format("{0}|{1}", obeMenuHijo.Accion,
obeMenuHijo.Ensamblado);
if (!obeMenuHijo.Accion.Equals("")) mnuHijo.Click +=
new EventHandler(ejecutarAccion);
mnuPadre.DropDownItems.Add(mnuHijo);
crearSubMenu(obeMenuHijo, mnuHijo);
}
}
private void ejecutarAccion(object sender,EventArgs e)
{
ToolStripMenuItem mnu = (ToolStripMenuItem)sender;
string[] opciones = mnu.Tag.ToString().Split('|');
string accion = opciones[0];
string nombreEnsamblado = opciones[1];
if (accion.StartsWith("frm"))
{
Assembly ensamblado = Assembly.LoadFrom(nombreEnsamblado);
if (ensamblado != null)
{
Type tipo = ensamblado.GetType(String.Format("{0}.{1}",
Path.GetFileNameWithoutExtension(nombreEnsamblado),accion));
if (tipo != null)
{
object obj = Activator.CreateInstance(tipo);
if (obj != null)
{
Form frm = (Form)obj;
frm.MdiParent = this;
frm.Show();
}
}
}
}
else
{
if (accion.EndsWith(".exe"))
{
Process.Start(accion);
}
else
{
opciones = accion.Split('.');
accion = opciones[0];
string clase = opciones[1];
if (nombreEnsamblado.Equals("SistemaPrincipal.exe") &&
clase.Equals("frmPrincipal"))
{
MethodInfo mi = this.GetType().GetMethod(accion);
var rpta = mi.Invoke(this, null);
if (rpta != null) MessageBox.Show(rpta.ToString());
}
else
{
Assembly ensamblado = Assembly.LoadFrom(nombreEnsamblado);
if (ensamblado != null)
{
Type tipo = ensamblado.GetType(String.Format("{0}.{1}",
Path.GetFileNameWithoutExtension(nombreEnsamblado), clase));
if (tipo != null)
{
object obj = Activator.CreateInstance(tipo);
if (obj != null)
{
MethodInfo mi = tipo.GetMethod(accion);
if (mi != null)
{
var rpta = mi.Invoke(obj, null);
if (rpta != null) MessageBox.Show(rpta.ToString());
}
}
}
}
}
}
}
}
public void salirApp()
{
this.Close();
}
}
}
Nota: Asociar al evento "Load" del formulario "frmPrincipal" el método: "llenarMenus", el cual lista las opciones de la raíz o primer nivel, luego la función "crearSubMenu" recursivamente llena los demás niveles.
Crear el Archivo de Texto con las opciones del menu principal
Antes de crear el archivo de texto, hay que grabar y compilar la aplicación y luego ir a la carpeta "bin", "debug" y crear el archivo de texto "Menus.txt" similar a la figura mostrada:
Primera Prueba de la Aplicación Sistema Principal
Si se ejecuta la aplicación se mostrará el MDI con los menús cargados y si abrimos los formularios se mostrará similar a la siguiente figura:
Nota: La primera prueba consiste en mostrar solo las opciones que estan dentro del propio sistema (sin integración).
Crear otra Aplicación Windows Forms con el Módulo de Procesos
Crear una nueva aplicación Windows Forms en C# llamada "ModuloProcesos", cambiarle de nombre al formulario por "frmPrincipal" y configurar su propiedad BackColor en Green, y realizar el diseño similar a la figura mostrada:
Agregar 2 formularios al proyecto (configurar su propiedad BackColor en Green), con los siguientes nombres:
- frmNuevaOrden.cs: Propiedad Text en "Modulo de Procesos - Nueva Orden"
- frmNuevaFactura.cs: Propiedad Text en "Modulo de Procesos - Nueva Factura"
Escribir el siguiente código en el formulario "frmPrincipal":
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
namespace ModuloProcesos
{
public partial class frmPrincipal : Form
{
public frmPrincipal()
{
InitializeComponent();
}
Crear una Librería de Clases con el Módulo de Reportes
Crear una nueva Librería de Clases en C# llamada "ModuloReportes", cambiarle de nombre a la clase por "Rutinas.cs" y escribir el siguiente código:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace ModuloReportes
{
public class Rutinas
{
public string procesar()
{
return "Procesando";
}
}
}
Hacer referencias a 2 librerías: System.Drawing.dll y System.Windows.Forms.dll
Agregar 2 formularios al proyecto (configurar su propiedad BackColor en Blue), con los siguientes nombres:
- frmRepCliente.cs: Propiedad Text en "Modulo de Reportes - Clientes"
- frmRepOrden.cs: Propiedad Text en "Modulo de Reportes - Ordenes"
Grabar y compilar la librería.
Nota: Esta No se puede ejecutar porque es una librería de clases, solo funciona desde una aplicación que la llame.
Segunda Prueba de la Aplicación Sistema Principal
Recuperar la aplicación "SistemaPrincipal", sacar una copia al archivo "Menus.txt" (carpeta bin, debug) y aumentar mas opciones al archivo, tal como se muestra en la siguiente figura:
Copiar los archivos ModuloProcesos.exe y ModuloReportes.dll hacia la carpeta bin, debug donde se encuentra la aplicación SistemaPrincipal.exe y el archivo Menus.txt.
Ejecutar nuevamnete la aplicación y se mostrará el MDI con los menús cargados (los cuales han aumentado) y si abrimos los formularios se mostrará similar a la siguiente figura:
Observe que cada color diferencia el ensamblado donde se encuentra el formulario:
- Rojo: Formularios de la Aplicación Sistema Principal
- Verde: Formularios de la Aplicación Modulo Procesos
- Azul: Formularios de la Librería de Clases Modulo Reportes
También observe que al seleccionar "Reportes", "Graficos", "Estadistica" se ejecuta un método externo "procesar" encontrado en la Librería de Clases "ModuloReportes.dll" y cuando se elige la opción "Salir" se ejecuta el método "salirApp" ubicado en la misma clase del formulario MDI.
Comentario Final
En este post, hemos visto como aumentar funcionalidad a una Aplicación Windows sin Recompilar la Aplicación usando Reflection. Los menús se han cargado usando un archivo de texto, pero en vez de este puede ser una tabla de una base de datos.
Si bien es cierto, el uso intensivo de Reflection (sobre todo llamadas en bucles), no es recomendable, existen muchos casos como en este, que nos sirven de gran ayuda.
Muchos desarrolladores, desconecen la importancia y la gran cantidad de usos que se pueden dar a Reflection, pero en este Blog siempre estamos dando a conocer su importancia para darle "inteligencia" a tus soluciones.
Video del Demo
Aquí les dejo, un video parecido al Demo posteado, con la diferencia que la aplicación SistemaPrincipal se llama Demo12, la aplicación ModuloProcesos se llama Demo13 y la librería ModuloReportes se llama Demo14, pero igual les puede servir de guia.
Titulo: Building JavaScript Games
Autor: Arjan Egges
Editorial: Apress
Nro Paginas: 422
Capítulos:
Part I: Getting Started
Chapter 1: Programming
Chapter 2: Game Programming Basics
Chapter 3: Creating a Game World
Chapter 4: Game Assets
Part II: Creating Colorful Games
Chapter 5: Knowing What the Player Is Doing
Chapter 6: Reacting to Player Input
Chapter 7: Basic Game Objects
Chapter 8: Game Object Types
Chapter 9: Colors and Collisions
Chapter 10: Limited Lives
Chapter 11: Organizing Game Objects
Chapter 12: Finishing the Painter Game
Part III: Jewel Jam
Chapter 13: Adapting to Different Devices
Chapter 14: Game Objects in a Structure
Chapter 15: Gameplay Programming
Chapter 16: Game States
Chapter 17: Finishing the Jewel Jam Game
Part IV: Penguin Pairs
Chapter 18: Sprite Sheets
Chapter 19: Menus and Settings
Chapter 20: Game State Management
Chapter 21: Storing and Recalling Game Data
Chapter 22: Pairing the Penguins
Chapter 23: Finishing the Penguin Pairs Game
Part V: Tick Tick
Chapter 24: The Main Game Structure
Chapter 25: Animation
Chapter 26: Game Physics
Chapter 27: Intelligent Enemies
Chapter 28: Adding Player Interaction
Chapter 29: Finishing the Tick Tick Game
Part VI: Into the Great Wide Open
Chapter 30: Producing Games
Chapter 31: Publishing Games
Titulo: MCTS Exam 70505. NET Framework 3.5 Windows Forms Application Development
Autor: Matthew A. Stoecker, Steve J. Stein
Editorial: Microsoft
Nro Paginas: 774
Capítulos:
CHAPTER 1 Windows Forms and the User Interface
CHAPTER 2 Configuring Controls and Creating the User Interface
CHAPTER 3 Advanced Windows Forms Controls
CHAPTER 4 Tool Strips, Menus, and Events
CHAPTER 5 Configuring Connections and Connecting to Data
CHAPTER 6 Working with Data in a Connected Environment
CHAPTER 7 Create, Add, Delete, and Edit Data in a Disconnected Environment
CHAPTER 8 Implementing Data-Bound Controls
CHAPTER 9 Working with XML
CHAPTER 10 Printing in Windows Forms
CHAPTER 11 Advanced Topics in Windows Forms
CHAPTER 12 Enhancing Usability
CHAPTER 13 Asynchronous Programming Techniques
CHAPTER 14 Creating Windows Forms Controls
CHAPTER 15 Deployment
Titulo: MCTS Exam 70526. NET Framework 2.0 Windows Based Client Development
Autor: Matthew A. Stoecker, Steve J. Stein
Editorial: Microsoft
Nro Paginas: 793
Capítulos:
1. Windows Forms and the User Interface
2. Configuring Controls and Creating the User Interface
3. Advanced Windows Forms Controls
4. Tool Strips, Menus, and Events
5. Configuring Connections and Connecting to Data
6. Working with Data in a Connected Environment
7. Create, Add, Delete, and Edit Data in a Disconnected Environment
8. Implementing Data Bound Controls
9. Working with XML
10. Printing in Windows Forms
11. Advanced Topics in Windows Forms
12. Enhancing Usability
13. Asynchronous Programming Techniques
14. Creating Windows Forms Controls
15. Deployment
Titulo: Beginning CSS3
Autor: David Powers
Editorial: Apress
Nro Paginas: 547
Capítulos:
Part I: CSS Basics
Chapter 1: Introducing CSS The Language of Web Design
Chapter 2: Using Basic Selectors
Chapter 3: Specifying Sizes, Colors, and Files
Part II: Working with Text
Chapter 4: Styling Text
Chapter 5: Embedding Web Fonts
Part III: CSS Page Layout
Chapter 6: Understanding the CSS Box Model
Chapter 7: Floating Elements for Layout
Chapter 8: Adding Backgrounds
Chapter 9: Adding Borders and Drop Shadows
Chapter 10: Styling Lists and Navigation Menus
Chapter 11: Positioning Elements Precisely
Chapter 12: Cross-Browser Layout Techniques
Part IV: Advanced CSS Techniques
Chapter 13: Using Advanced Selectors
Chapter 14: Styling Tables
Chapter 15: Generated Content
Chapter 16: Creating a Print Style Sheet
Chapter 17: Targeting Styles with Media Queries
Chapter 18: Using CSS3 Multi-Column Layout
Chapter 19: Creating Gradients Without Images
Chapter 20: 2D Transforms and Transitions
Chapter 21: Animating with CSS Keyframes
Chapter 22: What Next?
Titulo: jQuery UI 1.10 The User Interface Library for jQuery
Autor: Alex Libby, Dan Wellman
Editorial: Packt
Nro Paginas: 502
Capítulos:
Chapter 1: Introducing jQuery UI
Chapter 2: The CSS Framework and Other Utilities
Chapter 3: Using the Tabs Widget
Chapter 4: The Accordion Widget
Chapter 5: The Dialog
Chapter 6: The Slider and Progressbar Widgets
Chapter 7: The Datepicker Widget
Chapter 8: The Button and Autocomplete Widgets
Chapter 9: Creating Menus
Chapter 10: Working with Tooltips
Chapter 11: Drag and Drop
Chapter 12: The Resizable Component
Chapter 13: Selecting and Sorting with jQuery UI
Chapter 14: UI Effects
Appendix: Help and Support
