Subscribe to Updates

Click here to subscribe to new posts by email. We use Google FeedBurner to send these notifications.

Archive for the ‘BookBuilder’ Category

PocketBible for Mac OS Stretch Goals and New Add-On Rewards

Posted on: July 10th, 2013 by Craig Rairdin 5 Comments

I was surprised to see that we reached our $28,500 funding goal for PocketBible for Mac OS on the morning of July 10! Thank you so much for your support!

We still have five days left before the Kickstarter project stops accepting pledges, so here’s what we’d like to do: We are announcing a “stretch goal” of $33,500. If we reach that funding level, we’ll include BookBuilder Pro for Mac in the project. And to help us get there, we’re adding some rewards to attract our non-Mac users (and Mac users) to pledge.

BookBuilder Pro is the tool we use in-house to create add-on reference books and Bibles for PocketBible. Right now it’s a Windows-only product. In our effort to make Mac a “first-class” platform for our company, we’d like to be able to offer all the same products we have for Windows on the Mac platform. If you’ll take us to $33,500 we’ll make sure that happens.

We also want to offer some new rewards, most of which would be attractive to all PocketBible users, not just those of you with Macs. We’re adding the following rewards:

  • John Gill’s Exposition of the Entire Bible: $20 ($29.99 value, http://LPB.cc/JGEEB)
  • Barne’s Notes on the Bible: $35 ($49.99 value, http://LPB.cc/BNB)
  • John Wesley’s Notes on the Bible: $17 ($24.99 value, not yet completed so no product page to link to)
  • Darby’s Synopsis of the Books of the Bible: $10 ($14.99 value, http://LPB.cc/SYNBB)
  • Laridian Book of Classic Hymns: $9 ($12.99 value, http://LPB.cc/LBCH)
  • Laridian English Dictionary: $9 ($12.99 value, http://LPB.cc/LED)

We will fulfill these rewards as soon as the Kickstarter campaign is complete. They tell us it takes a couple weeks after the campaign closes before we’ll have a final list of backers. The rewards above will be fulfilled as soon as possible after we have that list.

Note that all of the books above are included in the five “PocketBible Library” collections offered as rewards already. So: If you have not pledged yet, you can choose one of these new rewards. If you’ve already pledged something less than $50 for the $50 reward, you can modify your pledge (increasing it if necessary) and choose one of these rewards. Or if you’re at the $25 level you can add to your pledge and at the end of the campaign we’ll contact you and you can tell us to use the excess in your pledge to get one of these rewards.

If we reach our stretch goal, we’ll give you the chance to add BookBuilder Pro, a $49.99 value, to your reward package for $35. If you’re interested in BookBuilder Pro, just go to Kickstarter and modify your pledge to add $35. At the end of the campaign we’ll contact you to find out how you want to allocate the extra funds. At that time you’ll be able to select BookBuilder Pro as an add-on reward, assuming we reach the stretch goal of $33,500.

In summary here’s what you should be thinking about depending on where you’re at with your pledge:

  • Best Value: The absolute best value in the list of rewards is the Exclusive Kickstarter Edition PocketBible Library. Most of the rewards are worth 3% to 30% more than the minimum pledge. The Kickstarter Edition is $900-$950 worth of products for $500. That’s almost twice the value of your pledge. Think of it this way: Your $300 pledge gets you the Platinum Edition Library and Advanced Feature Set, which you’ll be able to get for about $310 the day after PocketBible for Mac ships. But your $500 pledge gets you the Kickstarter Edition Library, which will cost you over $900 when PocketBible for Mac ships. Without a doubt, it is your best value.
  • Mac Users: Add $35 to your pledge. If we top $33,500 we’ll give you the opportunity to add BookBuilder Pro for Mac to your reward.
  • Mac Users pledging less than $50: Add $9 or more to your pledge. You can either select one of the new add-on book rewards if you haven’t selected a reward already, or you’ll be able to add one of those books to your existing $25 reward. We’ll contact you when the campaign is complete to find out what you want to do.
  • Windows/Non-Mac users: Consider helping your Mac-based brothers and sisters out by pledging as little as $9 and selecting one of the new add-on book rewards. We’ll fulfill these rewards as soon as Kickstarter provides us the final backer list.
  • Everyone: Add anything to your pledge to push us over our new stretch goal of $33,500!

NEW! Export, Share and Publish your PocketBible Notes, Bookmarks and Highlights

Posted on: October 16th, 2012 by Michelle Stramel 24 Comments

Are you a prolific note-taker, highlighter or bookmarker in PocketBible? We have wonderful news for you! We have a new option on our website that lets you instantly pull your personal data (notes, highlights and bookmarks) out of PocketBible for the purpose of sharing, re-purposing or turning into your own PocketBible book (with BookBuilder). Whichever you want to do!

Possibilities abound

Over the years, PocketBible users have asked for the ability to export their valuable personal data out of the program. Yes, you can now do this but we’ve taken it a step further. You choose whether you want to export your notes, highlights or bookmarks. With any of those three options, we provide you with an html file that you can:

  • Use as-is
  • Bring into a text editor and reformat and publish in a format for sharing (i.e. PDF, .doc, .txt, etc.)
  • Publish as a PocketBible book using Laridian BookBuilder program (sold separately)

What kind of book could you publish for PocketBible?

  • A dictionary of your Bible bookmarks, where each dictionary entry is a bookmark category.
  • A commentary based on your verse notes.
  • A dictionary of your Bible highlights, where each dictionary entry is a highlight color.

To encourage your self-publishing efforts, we’ve lowered the prices of both versions of BookBuilder:

There’s never been a better time to consider publishing a PocketBible book!

Getting Started

The first step is to synchronize your PocketBible data with the Laridian Server. A synchronization option is available in every version of PocketBible (except Android OS – still to come!) The second step is to login to your account on the Laridian website and choose the new My Data link. You’ll find complete information on what you can do with your data and how to do it.

Let us know what you think

We hope you like this new flexibility in using your personal PocketBible data. Is this something you will use? Let us know how you will share your writings in the comments below.

The Story Behind the PocketBible NET Bible

Posted on: January 11th, 2010 by Craig Rairdin 11 Comments

We’ve known about the NET Bible since its beginnings, and several years ago we licensed the NET Bible for use in our products. We knew the Bible had extensive notes but didn’t think that would be a problem for PocketBible.

We put one of our employees to work on it and after several months it became clear that the challenges it presented were going to be greater than the potential revenue we could gain from it would justify. The problems were related to converting the original language references in the notes from a variety of proprietary fonts into the standard Unicode notation we use in PocketBible. I don’t recall all the details but do recall a meeting in which we decided to just drop the project.

A year or so later we heard from a programmer who had extensive experience with the NET Bible and wondered why we hadn’t yet made it available. I explained the issues and he said he’d be happy to tackle it. I sent him everything he needed to tag the NET Bible and notes for PocketBible. He asked a couple questions over the next week or two, but then disappeared. The NET Bible had taken another victim.

Then last November I heard from David Richards. David is a long-time Laridian customer and a fan of the NET Bible. He had been experimenting with our BookBuilder program, which allows anyone to create reference materials that are compatible with PocketBible, and wondered if we had plans to publish the NET Bible. I told him the story and warned him of the bodies it had left in its path. He seemed undeterred, so we came to terms on a price for his work and he set out to work on it. I figured that would be the last we’d hear from him, and went about my business.

Surprisingly, when I heard from David it wasn’t to ask questions. It was to give me samples from what he had gotten done. Before long he had made it through all 60,000 notes. We ran a brief test with a group of testers left over from PocketBible for iPhone and after just one update the NET Bible was ready to ship.

I wanted to tell you David’s story for a couple reasons. First is that we’re pretty excited about finally having the NET Bible and know what an accomplishment it was for him. He deserves a little recognition for his efforts.

Second is that David’s is a story we’ve seen play out a couple of times in the past and we’d like to see it happen more often. We’ll be releasing a collection of reference books in the next couple of weeks that were tagged by another customer who got interested in BookBuilder a year or two ago and has since tagged a couple of projects for us after doing some of his own. Our A.W. Pink, F.B. Meyer, and Andrew Murray collections were tagged by a customer, as was the Dake Study Bible Notes.

Of course tagging books isn’t for everyone. It usually requires extensive use of what’s called “pattern matching”, “regular expression”, or “grep” search-and-replace operations to convert a book from whatever format it might be to begin with into our HTML-based format for BookBuilder. You need to have a head for details and it doesn’t hurt to have a little programming background.

David and each of these other taggers are being compensated in some way for their work. We’d love to add you to our list of available taggers for new projects. You can get the standard BookBuilder program for $29.99 and see if it’s something you want to try. We have an inexhaustible list of books that need to be tagged. Maybe you have a favorite commentary series or reference title you’d like to see in PocketBible. Rather than wait for us to get around to it, why not volunteer to do it yourself?

Feel free to contact me directly if you’re interested: craigr@laridian.com.

Quick and Easy Custom “Books” for PocketBible Using BookBuilder

Posted on: April 28th, 2008 by Craig Rairdin 5 Comments

I get the best ideas from customers. I’m corresponding with one now who is lamenting how hard it is to use BookBuilder to bring a text file into PocketBible. That gave me an idea to just tell you how to do it. It’s pretty easy.

Let’s just take the text of my blog posting from April 21 and turn it into a Laridian book. Laridian books are HTML files with some added tags. They all look like this:

<html><head>
<!– meta tags go here –>
</head><body>
<!– your book goes here–>
</body></html>

The meta tag section comes right out of the documentation. Here are the meta tags for a dictionary, which we’ll modify to make our book:

<html><head>
<meta name=”pb_title” content=”Tyndale Bible Dictionary”>
<meta name=”pb_abbrev” content=”TBD”>
<meta name=”pb_copyright” content=”Copyright &copy; 2001 by Tyndale House Publishers, Inc. All rights reserved.”>
<meta name=”pb_publisher” content=”Laridian Electronic Publishing”>
<meta name=”pb_city” content=”Cedar Rapids, IA”>
<meta name=”pb_date” content=”2004″>
<meta name=”pb_pubid” content=”101″>
<meta name=”pb_bookid” content=”35″>
<meta name=”pb_editionid” content=”1″>
<meta name=”pb_revisionid” content=”1″>
<meta name=”pb_synctype” content=”word”>
</head><body>
<!– your book goes here–>
</body></html>

We’ll change a bit of the text in the meta tags to make it make sense for our blog article. We end up with this:

<html><head>
<meta name=”pb_title” content=”April 21 Blog Article”>
<meta name=”pb_abbrev” content=”BLOG”>
<meta name=”pb_copyright” content=”Copyright &copy; 2008 by Craig Rairdin. All rights reserved.”>
<meta name=”pb_publisher” content=”Laridian Electronic Publishing”>
<meta name=”pb_city” content=”Cedar Rapids, IA”>
<meta name=”pb_date” content=”2008″>
<meta name=”pb_pubid” content=”9999″>
<meta name=”pb_bookid” content=”1″>
<meta name=”pb_editionid” content=”1″>
<meta name=”pb_revisionid” content=”1″>
</head><body>
<!– your book goes here–>
</body></html>

In addition to changing the text of the copyright message etc. I also changed the Publisher ID (pb_pubid) just because it doesn’t matter and I didn’t want it the same as the Tyndale Dictionary from which the example was lifted. I set the pb_bookid meta tag to 1, and I would change that for every book I create. And I removed the final pb_synctype tag, because that’s what tells PocketBible this is a dictionary, but my file isn’t a dictionary.

I have to add at least one heading so I have something in the table of contents for the book. So I put that on the top of the text of the blog article. I paste in the text of the blog article and add <p> tags at the start of each line to indicate new paragraphs.

Text in bold is text I modified in some way just so you can see how little I changed from either the sample meta tags or the text of my article.

<html><head>
<meta name=”pb_title” content=”April 21 Blog Article“>
<meta name=”pb_abbrev” content=”BLOG“>
<meta name=”pb_copyright” content=”Copyright &copy; 2008 by Craig Rairdin. All rights reserved.”>
<meta name=”pb_publisher” content=”Laridian Electronic Publishing”>
<meta name=”pb_city” content=”Cedar Rapids, IA”>
<meta name=”pb_date” content=”2008“>
<meta name=”pb_pubid” content=”9999“>
<meta name=”pb_bookid” content=”1“>
<meta name=”pb_editionid” content=”1″>
<meta name=”pb_revisionid” content=”1″>
</head><body>
<h1 pb_toc=visible>On the Problems of Designing User-Friendly Software for PDAs and Smart Phones</h1>
<p>A comment from one of our PocketBible 4 beta testers got me thinking about the nature of what we do and what users complain about. I’ve expressed this with respect to the iPhone but I haven’t put it into a larger context that might help people understand what software designers are up against when we implement a solution, regardless of the platform. These issues are especially true of the mobile device market but the same ideas apply to the desktop and other general-purpose computing platforms.
<p>If you start from the beginning, you find a user with a problem. It might be: “How do I take my contact database with me?” or “How can I work on my spreadsheets on the train?” or “How can I browse the Web when I’m away from my computer?”. Hardware companies like Sony, Apple, HP, and HTC get together with software companies like Microsoft and whatever Palm is calling itself today and come up with a device and operating system software that address those problems. In the course of doing so, they create a way for third parties (that’s us) to create software for their new device/OS platform.
<p>By the time we consumer software companies (independent software vendors or ISVs) get our hands on these products, we’re no longer solving the original customer problem. Instead, we’re programming for a device, and the device is solving the problem. When we program for a device we have certain limitations imposed by the hardware and software. The screen is only so big. There may or may not be a keyboard. There may or may not be much memory. There may or may not be good internet connectivity. The tools provided by the OS software developer may not be very powerful. There are a host of these limitations, and we have no control over them. It is the sandbox in which we have to play if we’re going to play at all.
<p>etc…..
</body></html>

That’s all there is to it. If you can master cut and paste and typing <p> you can create books out of text files. If you know a little HTML you can add bold, italics, underlines, and even tables and lists.

Regular Expressions 101 (Part 1)

Posted on: April 6th, 2007 by Craig Rairdin 1 Comment

Note: This corrects some missing pieces of information from the newsletter version of this article.

As users of PocketBible and MyBible you are aware that Laridian licenses books from Christian publishers and publishes them electronically. These include Bibles, commentaries, Bible dictionaries, devotionals and other Bible reference works that aren’t covered by those four general categories.

Since you’re getting this newsletter you are also familiar with our BookBuilder program which allows you to take original content (or content for private use) and turn it into a Laridian electronic book (.lbk). What you may or may not realize is that BookBuilder is the same program that we use internally to develop content for PocketBible and MyBible.

When we license content from Bible publishing houses we take what they give us as “electronic” files and turn it into what you purchase and install on your device. We get lots of different file formats from publishers: text files, pdf files, Quark files, Word documents, etc.

Since we get so many different file types there isn’t a specific program or procedure that we can use to automatically turn them into an .lbk. (Wouldn’t that be nice!?) The process is similar for each title, but not standardized.

What we work towards is to get every title into an html format and then we use TextPad to edit the html file. (An evaluation copy of TextPad is included with the BookBuilder product and also available at http://www.textpad.com/.)

One of the reasons we use TextPad is that it supports Search and Replacing using “Regular Expressions.” Regular Expressions (regexp or regexes) are a (very powerful) way of finding text using pattern matching. So, for instance, I can use regexps to find Bible references in a book file and insert tags around the references in a global manner.

Here’s an example:

To find Gen 2:7 or Romans 3:23 I would use the following regexp:

([A-Za-z]*)([0-9]*):([0-9]*)

The [A-Za-z] tells TextPad (or any other program that support regexp) to look for any letter, capital or lower case. The () around the [A-Za-z] is regexp way of telling the program to hold on to that character. The * tells the program that I’m looking for one or more character that matches and allows the program to keep it as a string. In our Bible reference example this would be Gen or Romans.

The next thing that you see in the regexp is a space. (Represented by ␢.) This is important as it helps to establish the pattern for which we are looking.

Understanding what the [A-Za-z] is doing makes it fairly straightforward to see what the next group is doing. [0-9] is looking for any number zero through nine. Again the () and * tell the program that we want to hang on to the string and it may be one or more character. In our Bible reference example this is the 2 or 3 indicating the chapter number.

The semicolon next again helps to establish the pattern. And the repeated ([0-9]*) is asking for the verse numbers. In our example the 7 and 23.

So, now what?

Now that you have the pattern established you can put this into the “Find what” field in TextPad. Making sure that the “Regular Expression” box is checked when you click “Find Next” you will step through your document finding each occurrence of a basic Bible reference.

The next step is to write your “Replace with” expression.

In the Laridian book we show that a Bible reference is a Bible reference using the following tag:

<pb_link format=”bcv | bc | cv | c | v”>…</pb_link>

So we would want the following tags for our examples:

<pb_link format=”bcv”>Gen 2:7</pb_link>

and

<pb_link format=”bcv”>Romans 3:23</pb_link>

Creating our “Replace with” expression is simple:

<pb_link format=”bcv”>1␢2:3</pb_link>

The only part of this expression that is regexp syntax are the 1 2 and 3. These indicate the three strings of () that we had collected in our “Find what” expression and indicate to the program where to place each string.

and. These indicate the three strings of that we had collected in our “Find what” expression and indicate to the program where to place each string.Two things to note:

1.) What I’ve just demonstrated here is done automatically in the VerseLinker program so it is rare that you would use this exact regexp in a Search and Replace. However, once you understand this you can use it to insert tags in commentaries that indicate where to place index and sync tags. (Your “Replace with” will be a different tag.) It also lays the ground work for some other powerful regexp that we’ll talk about in a later newsletter.

2.) This example will only find simple straightforward Bible references. You will need to restructure your “Find what” expression to find the following different kinds of Bible references: 1 Samuel 3:7-12; v. 1-3; Num 4; 3 John 8; Jude 3; etc. All of these can be handled with regexp, you just need to figure out how to structure your expressions.

This is a very simple example of what is a very powerful and potentially complex tool that we use to tag our books. Over the next few newsletters I’ll talk about more of the basics of regexp and maybe tackle some higher level expressions. In the course of tagging numerous books there really are only a handful of basic regexp components that are used regularly. I’ll try to cover these to give you what you need to tag just about anything.

Let me know if you have any specific questions or would like clarification on any of this.

New BookBuilder Update Released

Posted on: April 6th, 2007 by Craig Rairdin 2 Comments

BookBuilder has been updated to add a couple of small error-detection enhancements. The new version numbers are:

  • BookBuilder for MyBible 4.x: 1.4
  • BookBuilder for PocketBible 3.x: 1.2
  • BookBuilder Professional: 1.6
  • BookBuilder for the older PocketBible 2.x for Pocket PC is unchanged.

We have improved detection of misspelled or completely unrecognized tags, especially when they occur at a location which could logically be the end of a paragraph. Prior versions would treat an unknown tag at the end of a paragraph as the end of the paragraph, then skip everything from that position to the beginning of the next paragraph.

Prior versions of BookBuilder treat this as an error (because there is no such thing as a <multicolored> tag):

<p>This text is <b>bold, now add <multicolored>some color </multicolored> and end bold.</b></p>

But they would not see this as an error (even though there’s no such thing as <smallcaps>):

<p>This paragraph contained <smallcaps>text in small caps</smallcaps></p>
<p>This paragraph is OK.</p>

The paragraphs above would be rendered as follows, and no error message would be generated:

This paragraph contained
This paragraph is OK.

The new version will correctly identify both the <multicolored> and <smallcaps> tags as unrecognized.

We have also improved the determination of the error context when describing the location of a missing or unrecognized tag. The code to determine the starting position of the bad tag was simply incorrect and usually resulted in error messages that weren’t very helpful. The new code should more correctly identify the starting position of the context of a bad tag. Some minor message format changes were also made to make these error messages easier to read.

It’s possible that books that built correctly with an old version of BookBuilder contained errors that this new version will find. It would be a good idea to run old books through this new version to verify there aren’t any undetected bad tags.

As usual, there is no charge for this update. Just log into your download account and re-download and re-install BookBuilder.

Common BookBuilder Tagging Errors (Part III)

Posted on: April 6th, 2007 by Craig Rairdin 2 Comments

This is the third in what’s turning out to be a series of articles on proper HTML syntax in BookBuilder and some common tagging problems we see in user-created books. I didn’t think this was going to be a trilogy when I started, but there seems to be no shortage of tagging issues we can discuss. Here are a few more.

(more…)

BookBuilder Updated – Version 1.5

Posted on: December 17th, 2006 by Craig Rairdin 5 Comments

BookBuilder is a constantly evolving program. As we release new content for PocketBible and MyBible, we encounter new challenges in dealing with the text we receive from publishers. As a result we’re often making small tweaks to BookBuilder, VerseLinker, and the other tools that make up the BookBuilder family of products.
(more…)

BookBuilder Tech Tips: More Common Tagging Errors

Posted on: December 17th, 2006 by Craig Rairdin No Comments

The HTML parsing engine we use in BookBuilder is more sensitive to HTML syntax errors than your typical Web browser. We continue our article from a couple months ago regarding some common tagging habits that may cause errors when you try to build your book.
(more…)

BookBuilder Tech Tips: Proper HTML Syntax

Posted on: September 27th, 2006 by Craig Rairdin 1 Comment

The HTML parsing engine we use in BookBuilder is more sensitive to HTML syntax errors than your typical Web browser. Some commonly held bad habits will cause errors when you try to build your book. Here are some specific examples.

Improper use of <p> tag

There are two common but incorrect ways to use the <p> tag. Most people understand that the closing </p> tag is optional, but some have a habit of not using the opening <p> tag and instead using only </p>. This works in many browsers but not in BookBuilder. Others put <p> at the end of their paragraphs. This is actually interpreted by the browser or BookBuilder as a <p> at the beginning of the next paragraph. This may not cause problems but it leaves the first paragraph without a <p> tag and it adds an extra <p> tag at the end.

We’ve also seen people not use the <p> tag at all. Some use line breaks (<br> tags) at the end of paragraphs. The problem with this is that our readers load and display whole paragraphs at a time. If you write a long section of text with no <p> tags (using <br> tags to break lines at the end of your “paragraphs”), the program will have to load the entire section into memory before any of it can be displayed. This will cause noticeable delays in displaying your text.

Improper construction of lists

The <ul> and <ol> tags demarcate unordered (bulleted) and ordered (numbered) lists. Between <ul> and </ul> (or <ol> and </ol>) you are allowed only list items (<li> tags). You cannot intermix paragraphs (<p> tags) and list items.

Some browsers allow you to create a bulleted list by using <li> tags with no enclosing <ul> or <ol> tag. This is not proper HTML and will cause errors in BookBuilder.

The rule that disallows anything but list items within a list can also be inadvertently violated when embedding a list in another list. When creating an outline using list tags, make sure the sublists are enclosed inside the list item above them, as in the following example:

<ol type=I>
  <li>Main Point I
    <ol type=A>
      <li>Point A under I</li>
      <li>Point B</li>
    </ol></li>
  <li>Main Point II
    <ol type=A>
      <li>Point A under II
        <ol type=1>
          <li>Point 1 under A</li>
          <li>Point 2</li>
        </ol></li>
      <li>Point B under II</li>
    </ol></li>
</ol>

Note that all sublists are inside the <li>…</li> tags of the point directly above them.

As an efficiency consideration, remember that our readers load the entire outer list in memory at one time. If your outlines are long, they can take a long time to load and display. To avoid this problem, break your outermost list into pieces corresponding to list items. The list above would be rewritten as follows:

<ol type=I>
  <li>Main Point I
    <ol type=A>
      <li>Point A under I</li>
      <li>Point B</li>
    </ol></li>
</ol>
<ol type=I>
  <li value=2>Main Point II
    <ol type=A>
      <li>Point A under II
        <ol type=1>
          <li>Point 1 under A</li>
          <li>Point 2</li>
        </ol></li>
      <li>Point B under II</li>
    </ol></li>
</ol>

Note that it’s important to set the value parameter on list items after the first one so that the reader program knows this is a continuation of the previous list.

Improper use of tables

Tables, like lists, can be misued by including tags other than those allowed inside the <table>…</table> tags. You can not intermix paragraphs and table rows. The following might display correctly in your browser, but it will cause errors in BookBuilder:

<table>
  <tr><td>First row, first column</td><td>second column</td></tr>
  <p>This is a paragraph of text.</p>
  <tr><td>Second row, first column</td><td>second column</td></tr>
  Text without any tags
</table>

Both of the bold rows will cause errors.

Surrounding paragraphs with inline tags

Many browsers will allow you to create several bold paragraphs using syntax like this:

<b>
<p>This is the first bold paragraph…</p>
<p>This is the second…</p>
<p>And this is the third…</p>
</b>

This is illegal HTML. BookBuilder requires you to put inline tags like <b>, <i>, and <font> inside your paragraphs to comply with proper HTML syntax:

<p><b>This is the first bold paragraph…</b></p>
<p><b>This is the second…</b></p>
<p><b>And this is the third…</b></p>

Not reading the documentation

Finally, our best advice is to read and understand the BookBuilder documentation! It’s surprising how many questions we get are answered in the documentation. Spending a few minutes there will help you save hours of frustration later.

©2014 Laridian