OASIS Mailing List ArchivesView the OASIS mailing list archive below
or browse/search using MarkMail.

 


Help: OASIS Mailing Lists Help | MarkMail Help

docbook-apps message

[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]

Subject: Converting Docbook epub to Kindle shows warnings

Hello,

I'm using Apache Ant to create an epub with the XSL stylesheets. This
works fine.

During the conversion to .mobi via the Amazon command line tool
kindlegen I get several warnings which may indicate that the generated
epub has some issues. See below for the error messages. I attached the
file in question. I noted that in the Kindle version several TOC
entries are in the same line: I think this might be the reason for
this.

Has anyone seen such issues and know how to solve them?

Best regards, Lars

Warning(inputpreprocessor):W29004: Forcefully closed opened Tag: <dl>
      in file: /tmp/mobi-v0Xfht/OEBPS/bk01-toc.html     line: 0000004
Warning(inputpreprocessor):W29004: Forcefully closed opened Tag: <dd>
      in file: /tmp/mobi-v0Xfht/OEBPS/bk01-toc.html     line: 0000004
Warning(inputpreprocessor):W29010: Tag rejected due to being used in
unauthorized scope: <dt>
      in file: /tmp/mobi-v0Xfht/OEBPS/bk01-toc.html     line: 0000004
Warning(inputpreprocessor):W29010: Tag rejected due to being used in
unauthorized scope: <dd>
      in file: /tmp/mobi-v0Xfht/OEBPS/bk01-toc.html     line: 0000004
Warning(inputpreprocessor):W29010: Tag rejected due to being used in
unauthorized scope: <dt>
      in file: /tmp/mobi-v0Xfht/OEBPS/bk01-toc.html     line: 0000005
Warning(inputpreprocessor):W29010: Tag rejected due to being used in
unauthorized scope: <dd>
      in file: /tmp/mobi-v0Xfht/OEBPS/bk01-toc.html     line: 0000005
Warning(inputpreprocessor):W29004: Forcefully closed opened Tag: <dl>
      in file: /tmp/mobi-v0Xfht/OEBPS/bk01-toc.html     line: 0000005
Warning(inputpreprocessor):W29004: Forcefully closed opened Tag: <dd>
      in file: /tmp/mobi-v0Xfht/OEBPS/bk01-toc.html     line: 0000005
Title: Eclipse 4 Application Development

Eclipse 4 Application Development

Table of Contents

Foreword
Preface
1. Welcome
2. How this book is organized
3. Prerequisites
4. Errata
5. Tutorials, Exercises and Examples
6. Long lines
7. Source Code
8. About the Author
9. Acknowledgment
I. Overview of Eclipse 4
1. Introduction into Eclipse
1.1. What is Eclipse?
1.2. Eclipse Public License
1.3. What are Eclipse RCP applications?
1.4. Advantages of Eclipse based applications
2. Eclipse 4
2.1. What is Eclipse 4?
2.2. The Eclipse Platform project
2.3. What is the Eclipse e4 project?
2.4. Provisional API
3. Architecture of Eclipse
3.1. Eclipse based applications
3.2. Terminology
3.3. Important configuration files
4. Important user interface components
4.1. Windows
4.2. Parts
4.3. Perspective
4.4. PartStacks and PartSashContainers
5. Eclipse 4.2 bugs
II. Getting started with Eclipse 4
6. Tutorial: Installation of Eclipse 4.2
6.1. Prerequisites
6.2. Download and Install Eclipse 4.2
6.3. Install the Eclipse 4 tooling
7. Tutorial: Eclipse IDE Configuration
7.1. Include all plug-ins into the Eclipse search
7.2. Remove warnings for provisional API access
8. Tutorial: Eclipse 4 application using the wizard
8.1. Overview
8.2. Create project
8.3. Launch
9. Run Configurations
9.1. Overview
9.2. Launch parameters
9.3. Common run configuration problems
10. Features and product configuration files
10.1. Feature project
10.2. Product and application
10.3. Dependencies
10.4. Splash Screen, Launcher and Start Parameter
10.5. Eclipse 4 product configuration limitations
11. Product Export
11.1. Overview
11.2. Which artifacts are included in the export?
11.3. Exporting the product
11.4. Export for multiple platforms via the deltapack
11.5. Including the required JRE into the export
11.6. Common product export problems
12. Exercise: Export your product
III. Eclipse 4 Core Development
13. Eclipse 4 application model
13.1. What is the application model?
13.2. Where is the application model defined?
13.3. How is the model connected to my Java classes?
13.4. URI in the Model
13.5. Application model editor
13.6. Model access at runtime
13.7. Meta-model of the application model
13.8. Creation of the Application model
13.9. Overview of available Model elements
13.10. Model Addons
14. Model identifier and naming conventions
14.1. Identifiers for model elements
14.2. Best practices for naming conventions
15. Tutorial: Create an Eclipse plug-in
15.1. Create a plug-in project
15.2. Validate the result
16. Tutorial: From plug-in to Eclipse 4 application
16.1. Create Product configuration
16.2. Create a feature project
16.3. Enter feature dependencies in product
16.4. Create Application model
16.5. Add model elements to the application model
16.6. Start application
16.7. Add plug-in dependencies
17. Tutorial: Modeling a user interface
17.1. Overview
17.2. Adding model elements
17.3. Create Java classes and connect to the model
17.4. Test
17.5. Tutorial: Configure the deletion of persisted model data
18. Dependency injection and annotations
18.1. What is Dependency Injection?
18.2. Define dependencies in Eclipse
18.3. Dependency injection in Eclipse 4
19. Scope of injection
19.1. What can be injected?
19.2. Key/values pairs and Context Variables
19.3. How are objects searched?
19.4. What are the relevant classes and interfaces
19.5. Who creates the context for model elements?
20. Behavior annotations
20.1. API definition via inheritance
20.2. API definition via annotations
20.3. Lifecycle Hooks
21. Tutorial: Using dependency injection
21.1. Getting a Composite
21.2. Validation
22. Tutorial: Define Part lifecycle
22.1. Overview
22.2. Using @PostConstruct and @PreDestroy
22.3. @Focus
22.4. Validate
23. Commands, Handler, Menus and Toolbars
23.1. Overview
23.2. Default commands
23.3. Menus and Toolbar
23.4. View Menus
23.5. Popup Menu - Context Menu
23.6. Scope of handlers
23.7. Several methods with @Execute
23.8. Passing parameters to commands
23.9. Core expressions
23.10. Evaluate your own values in Core expressions
23.11. Naming schema for command and handler IDs
24. Tutorial: Defining and using Commands and Handlers
24.1. Overview
24.2. Defining Commands
24.3. Defining Handler classes
24.4. Defining Handlers in your model
24.5. Adding a Menu
24.6. Adding a Toolbar
24.7. Closing the application
24.8. Simulate save
25. Key bindings
25.1. Overview
25.2. BindingContext entries using by JFace
25.3. Define Shortcuts
25.4. Key Bindings for a Part
25.5. Activating Bindings
25.6. Issues with Keybinding
26. Exercise: Define key bindings
27. Exercise: Integrating the live model editor
IV. Eclipse Core Technologies
28. Standard Widget Toolkit
28.1. Overview
28.2. Relationship to JFace
28.3. Display and Shell
28.4. Event loop
28.5. Using SWT
28.6. Using SWT in a plug-in project
28.7. Manually adding the SWT library
28.8. SWT Widgets
28.9. Event Listener
28.10. SWT Snippets, Examples and Nebula
29. SWT widget examples
29.1. Example: Create SWT project
29.2. DateTime widget
29.3. Image
29.4. CTabFolder
30. SWT layouts
30.1. Overview
30.2. Layout Data
30.3. FillLayout
30.4. RowLayout
30.5. GridLayout
30.6. Tab Order of elements
30.7. Example: Layouts in SWT
31. SWT Designer (WindowBuilder)
32. Exercise: Getting started with SWT Designer
32.1. Exercise: Install SWT Designer
32.2. Exercise: Using SWT Designer
33. Exercise: Build a SWT user interface
33.1. TodoOverviewPart
33.2. TodoDetailsPart
33.3. Implement @Focus
34. Modularity with OSGi
34.1. OSGi Overview
34.2. OSGi Bundles and Dependencies
34.3. Eclipse Equinox
34.4. OSGi console
35. Exercise: Creating the data model
35.1. Create plug-in
35.2. Create base class
35.3. Create model interface
35.4. Export the model
35.5. Providing data via a Singleton
35.6. Using the model Singleton
36. JFace
36.1. Eclipse JFace Overview
36.2. Eclipse JFace Viewers
36.3. JFace ComboViewer
36.4. Resource Manager for Colors, Fonts and Images
36.5. ControlDecorations
36.6. FieldAssists
37. Exercise: Build a Part with a ComboViewer
38. JFace Table Viewer
38.1. TableViewer
38.2. ContentProvider for TableViewer
38.3. Columns and LabelProviders
38.4. Reflect data changes in the Viewer
38.5. Editing Support
38.6. Filtering data
38.7. ViewerComparator
38.8. StyledCellLabelProvider
38.9. Show and hide table columns
38.10. Tooltips for Viewers
39. Exercise: JFace TableViewer
39.1. Create a JFace TableViewer for the Todo Items
39.2. JFace TreeViewer
40. Dialogs
40.1. Dialogs in Eclipse
40.2. SWT System Dialogs
40.3. JFace Dialogs
41. Exercise: Confirmation Dialog
42. Wizards
42.1. Overview
42.2. Wizards and WizardPages
42.3. Starting the Wizard
42.4. Changing the page order
42.5. Working with the same data on different pages
42.6. Tutorial: Wizards Example
43. Exercise: Create a Wizard for new Todos
44. Fragments Projects
44.1. Overview
44.2. Usage
45. Internationalization
45.1. Java Resource bundles and selection
45.2. Relevant files for translation
45.3. Best practices
45.4. Setting the language in the launch configuration
45.5. OSGi resource bundles
45.6. Translating plugin.xml
45.7. Translating the application model
45.8. Translating your source code
45.9. Exporting Plug-ins and Products
45.10. Flexible Eclipse 4 Internationalization
45.11. Common problems with i18n
46. Exercise: Internationalization
V. Eclipse 4 Advanced Development
47. Model dynamics at runtime
47.1. Overview
47.2. Example: Dynamically create a new Window
47.3. Example: Dynamically create a new Part
47.4. Example: Implement Editor behavior
48. Eclipse 4 Platform Services
48.1. Overview
48.2. Model Service
48.3. Part service
48.4. Selection service
48.5. Command and Handler service
49. Exercise: Selection and part service
49.1. SelectionService
49.2. Set TodoDetailsPart to dirty
49.3. PartService in a Handler
49.4. PartService in a Part
50. Asynchronous processing
50.1. User Interface Thread
50.2. Using syncExec() and asyncExec()
50.3. Eclipse 4 UISynchronize
50.4. Eclipse Jobs API
50.5. Priorities of Jobs
50.6. Blocking the UI and providing feedback
50.7. IProgressMonitor
50.8. Reporting Progress in Eclipse 4
51. Exercise: Using asynchronous processing
52. OSGi services
52.1. Overview
52.2. BundleContext
52.3. Registering services
52.4. Accessing a service
52.5. Selection of OGSi services
52.6. Best practices for defining services
52.7. OSGi Service Tracker
52.8. Problems with service tracker
53. Declarative OSGi services
53.1. Overview
53.2. Required bundles
53.3. Definition of a DS service
53.4. Defining start levels
53.5. Start level in Eclipse Products
53.6. OSGi Services and Eclipse Context
54. Exercise: Define and use an OSGi service
55. Exercise: Create an Image Loader Service
55.1. Loading Images
55.2. Create Bundle
55.3. Create OSGi bundle
56. Using dependency injection for your own Java objects
56.1. Overview
56.2. Using dependency injection to get your own objects
56.3. Using dependency injection to create objects
57. Accessing and extending the Eclipse context
57.1. Accessing the context
57.2. OSGi services
57.3. Objects and Context Variables
57.4. Model Addons
57.5. RunAndTrack
57.6. Context Functions
58. Exercise: Dependency injection for your own objects
59. JFace Databinding
59.1. Overview
59.2. PropertyChangeSupport
59.3. Observables
59.4. DataBindingContext and Bindings
59.5. UpdateValueStrategy
59.6. Converters and Validators
59.7. ControlDecorators
59.8. WritableValues
59.9. Listening to all changes in the binding
59.10. JFace Data Binding Plug-ins
60. Exercise: Databinding
61. Data Binding for JFace Viewer
61.1. Binding Viewers
61.2. Observing list details
61.3. ViewerSupport
61.4. Observing Viewer properties
61.5. Chaining properties
62. Exercise: Databinding Advanced
63. Eclipse Preferences
63.1. Preferences and Scopes
63.2. Eclipse Preference API
63.3. plugin_customization.ini
63.4. Eclipse 4 Preferences
64. Exercise: Preferences
65. Eclipse Event Notifications
65.1. Event based communication
65.2. IEventBroker Service
65.3. Usage
65.4. Evaluation
66. Exercises: Event Notifications
66.1. Exercise: Notifications for new Todos
66.2. Exercise: Splash Screen
67. Contributing to the application model
67.1. Eclipse 4 Modularity
67.2. Extending the application model
67.3. Constructing the runtime application model
67.4. Fragment extension elements
68. Tutorial: Fragments
68.1. Create Project and Java classes
68.2. Create model fragment
68.3. Register Fragment via extension point
68.4. Update Feature and test
68.5. Extend example: Contributing a Part
69. Tutorial: Processors
69.1. Enter dependencies and create Java classes
69.2. Register processor via extension point
70. Declarative Styling with CSS files
70.1. Cascading Style Sheets (CSS)
70.2. Eclipse 4 styling
70.3. Fixed styling via the applicationCSS parameter
70.4. Using the Theme Manager
70.5. Limitations
70.6. CSS Attributes
70.7. CSS Spy
70.8. Styling specific widgets
70.9. Colors and Gradients
70.10. CSS support for custom widgets
71. Exercise: Styling with CSS files
71.1. Create CSS file
71.2. Define applicationCSS property
71.3. Theme Manager and switching styles
72. Eclipse application updates with p2
72.1. Eclipse application Updates
72.2. p2 plug-ins
72.3. Creating update sites
72.4. Eclipse 4 and p2
73. Eclipse 4 testing
73.1. Introduction
73.2. Testing Eclipse 4 application
74. Target Platform
74.1. Developing against the Eclipse IDE
74.2. Defining your Target Platform
74.3. Creating a Target Platform definition
75. Eclipse 3.x applications with the compatibility layer
75.1. Running Eclipse 3.x plug-ins on top of Eclipse 4
75.2. Using features
75.3. Using plug-ins
75.4. Mixing Eclipse 4 and Eclipse 3.x
VI. Eclipse 4 Expert Development
76. Overview
77. Eclipse 4 dependency injection and own annotations
77.1. Define and evaluate own annotations
77.2. Usage
78. Tutorial: Defining own annotations
78.1. Overview and project creation
78.2. Define and evaluate annotations
79. Creating and evaluating Extension Points
79.1. Eclipse Extensions and Extension Points
79.2. Accessing Extensions
79.3. Creating an extension point
79.4. Extension Factories
80. Tutorial: Creating Extension Points
80.1. Overview
80.2. Create a plug-in which defines the extension
80.3. Define an extension point
80.4. Export Package
80.5. Evaluating the registered extensions
80.6. Providing an extension
80.7. Run the example
81. Renderer framework
81.1. Renderer
81.2. Define Renderer
81.3. Extend Eclipse application model
82. Tutorial: Defining a renderer
82.1. Project and classes
82.2. Register Renderer and start application
VII. Best practises and feedback
83. Best Practices for Eclipse 4 development
83.1. Extending the Eclipse Context
83.2. Application communication
83.3. Static vs. dynamic application model
83.4. Component based development
83.5. Usage of your own extension points
83.6. API definition
83.7. Packages vs. Plug-in dependencies
84. Questions and feedback
84.1. Eclipse Bugs
84.2. Asking (and answering) questions
84.3. Eclipse 4 feedback
85. Closing words
VIII. Appendix
86. Architectural background of the application model
86.1. Main areas of the model
86.2. Advantages of using Mix-ins
87. Receipts
87.1. Reading resources from plug-ins
87.2. Loading images from a plug-in
87.3. Specifying the location of the application model file
87.4. Getting the command line arguments
87.5. From plug-in to an Eclipse 4 application
87.6. Relevant extension points for Eclipse 4
88. Reference: Using EGit
88.1. EGit Installation
88.2. Clone existing project
88.3. Branching
89. Eclipse 4 platform development
89.1. Download and install Eclipse development build
89.2. Getting the Eclipse 4 source code
90. Web resources
90.1. Eclipse 4
90.2. Eclipse Bug Tracker and Eclipse Forum
90.3. Eclipse SWT Resources
90.4. JFace Resources
90.5. Eclipse DataBinding Resources
90.6. CSS Styling
90.7. Logging

[Date Prev] | [Thread Prev] | [Thread Next] | [Date Next] -- [Date Index] | [Thread Index] | [List Home]