Posts tagged: pika

  • Sunday
  • January 22
  • 2012

Integrating Gmail and Google Groups with the Pika CMS

A few weeks back the project team uploaded a complete version 4 code set to the LSNC Google API Project. This latest version is inclusive of four Google Apps core app integrations — Google Calendar, Google Docs, Gmail and Google Groups with the Pika CMS. This is the same project I described during my recent presentation at the 2012 TIG Conference in Albuquerque. As I noted there, we are spending the next few weeks doing expanded beta testing with users across varied positions and office locations within Legal Services of Northern California (LSNC). We expect to deploy all four integrations throughout the organization by the end of February.

In earlier posts I have described how the Google Calendar integration and Google Docs integration work. The short version is that, by exploiting the Google Apps APIs for Google Calendar and Google Docs, we have been able to implement a seamless synchronization between the Pika CMS calendar and document posting functions with Google Calendar and Google Docs. Pika CMS users need do nothing differently than what they are already doing to have tickler calendar events show up in their Google Calendars, or have case-related files uploaded to Pika show up in a case-specific shared collection in Google Docs.

The new Gmail integration in version 4 is arguably the most important of the four integrations. The basic user problem has been this: Everyone within LSNC — like most everyone else on professional planet Earth — day-in and day-out relies on email to accomplish their work. In our case, advocates regularly communicate with clients, co-counsel, opposing counsel, public and private individuals and entities and, of course, other LSNC staffers. But how are they to get those Gmail messages into case-related case notes in Pika? At the moment, what they do is cut-n-paste, again and again and again without end. The Gmail integration is designed to simplify that process so that users, from within a Gmail message or the entire conversation, can seamlessly post the content of Gmail messages to a client-specific case record automatically, without the need to open Pika.

To accomplish this, we have embedded a new Gmail widget that displays at the bottom of every Gmail message. Below is a screenshot of a developer version of the integration, with the gadget labeled as “TKLAPP Staging Pika – Attach to Case Notes.”

The default behavior of this gadget is to automatically copy the currently viewed Gmail message to the case notes in the selected client case record. To trigger that functionality, users toggle the gadget to display a dialog with a search option to locate any currently open client case record in Pika. Two tabs are available, one to search the user’s assigned active (open) cases and the other to search more broadly all cases active (open) throughout the organization. Once users select a case record, they have two check-box options: one to save any files attached to the Gmail message, which are automatically uploaded to the Pika case record and simultaneously synchronized to the user’s Google Docs account; the other to copy the entire Gmail conversation (Google’s name for an email message thread). Users can then simply click the “Attach to Case” button to seamlessly copy the Gmail message to the case record.

But wait… there’s more!

The gadget also offers an alternate input button allowing the user to “Edit and Attach to Case.” Clicking that button invokes a pop-up window with the Gmail message copied over to Google Docs for editing before the content is posted to Pika. The user can edit the single Gmail message or conversation as is their wont and then click on “Attach to Case” in the editing window to post the edited content to Pika. Done. Without ever having opened Pika.

The Google Groups integration works on the same premise as the Gmail integration, with the approach being to enable users to automatically copy a Groups discussion automatically to a Pika case record. The Groups solution is less elegant, however. Going into this project we made the mistaken assumption that, like the other Google Apps core applications, there was a Google API for Groups, but there is not. Google Groups has no exposed web API. So we did a workaround. The Google Groups integration with Pika requires the user add a custom bookmarklet to the browser bookmarks toolbar. Once that is set up, the user can go to a Business Groups discussion within our domain, click on the bookmarklet and trigger a set of dialogs directly analogous to how the Gmail integration works, with the ability to search for a specific client case record and then “attach” or “edit and attach” the content of the discussion message. (Google Groups no longer allows file attachments to discussion group messages, so there is no option to attach files.)

For those interested in this code set, you can anticipate there will be some minor updates to the code set over the next month or two as we fix quirks that emerge from our further beta testing. There is also an updated guide to installation coming soon.

Thanks again to everyone who attended the TIG presentation. It was encouraging to see how much interest there was within the larger legal services community in this project. My prediction is that within a few years we will all look back at this coding project as somewhat quaint, only a first step in many to come as we all increasingly rely on the Google Apps platform and work more with the Google API to take full advantage of it.

  • Wednesday
  • August 17
  • 2011

How the Google Docs integration with Pika works

The second version of the LSNC Google API Project includes an integration of Google Docs with the PHP-based Pika CMS. Implementation of this integration results in a totally seamless synchronization of Google Docs with any files added to a client-specific case record. Add a file to the case-record “documents” page in Pika, and that same file, in its original file format, is automatically synced to the Google Docs folder of all advocates associated with that particular case record.

Here are some screenshots to give you a feel for how it works: First, you upload the files to Pika, which natively stores the files in its database. This shows how the uploaded files display within the Pika user interface:

Second, well, that’s it. You’re done. Really.

Without any further user interaction required, Google Docs synchronizes with Pika and adds those same files to the individual Google Docs accounts of all the users associated with the client case record. The synchronization process adds the files to a client-specific subfolder, with the client’s last name and case number, residing below an upper level folder called “My Cases,” which is itself a special folder within the Google Docs “Collections shared with me.” For example, here are the same files synchronized to Google Docs to the folder labeled “Collections shared with me > My Cases > Forcast – 10-11-00004″ (to state the obvious, this is not a real client):

Once the Pika case-related documents are synchronized to Google Docs, the users can use the documents from within Google Docs as they would any other: navigate to it, search for it, view it, share it, download it, whatever. For example, here is how a Word file orginally uploaded to Pika and then synced to Google Docs looks in the view mode from within Google Docs:

So, imagine you get a Gmail or Google Chat message from another advocate, asking if you have a good example of a motion to quash a subpoena, and you know you have one in the “Forcast” case. Hey, you’re already in your Google Apps, so you just go to Google Docs, navigate or search for the case or document, and there it is. You go ahead and do a Google Docs share to the person who made the request. Done. Without ever having to even open up Pika.

That’s the name of that tune.

  • Thursday
  • August 4
  • 2011

Screenshots of the Pika gadget integration with Google Calendar

The goal of the LSNC Google API Project is to come up with practical integration of the Pika case management system with four core Google Apps. We have completed beta testing of two of those integrations, for Google Calendar and Google Docs, and this month are bearing down on the last two, for Gmail and Google Groups. The project as a whole will be completed by year’s end and will include documentation at the project code site to help IT folks familiar with Pika to replicate the project.

From the UX perspective, the goal is to create integrations that are as seamless as possible. For example, the first integration we built was one that synchronizes the Pika tickler calendaring function with the personal calendars of all the advocates associated with a particular client case record. For us the measure of success is that users continue to experience the Pika tickler functionality as they always have, but with the magic that their Pika tickler events automatically appear in their personal Google Calendars.

The integration requires the activation of a “Pika Gadget” via a new option in the individual user’s Pika account preferences. Clicking on the option triggers a standard Google dialog for confirming its activation:

Once activated, the Google Calendar synchronizes with Pika tickler activities. The tickler entries display and function exactly like any other item in one’s Google Calendar.

Here are a few screenshots illustrating how this all looks. In order, they are: A Pika tickler event page (which includes a new field for “Where,” corresponding to the same data in the Google Calendar); the tickled event displayed in the Google Calendar “day” view; the same event displayed in the Google Calendar “month” view; and the same event again, with the standard Google Calendar pop-up triggered when one clicks on the event in the Google Calendar:

As you can see from the last image, clicking on the tickler event from within Google Calendar triggers a display on the right with basic information about the related case record, including the case number, the client’s name, address and phone number. Clicking on the case number will open the corresponding case record within Pika. Users can also edit the tickler or add a new one to the particular case by clicking on the corresponding buttons displayed below the case information. That’s how that works.

Fellow Pika users: Don’t thank me. Thank Michael Cizmar at MC+A, the Gandalf of Google APIs!

  • Tuesday
  • April 26
  • 2011

Google Calendar component of LSNC Google API Project posted

The LSNC Google API Project has posted its first code iteration, an integration of Google Calendar with the Pika CMS. This first iteration includes basic installation instructions for implementing the integration. You can expect additional code iterations over the next several months as we roll out code integrations with Gmail, Google Docs and Google Groups.

LSNC’s development partner on this project is Michael Cizmar and his team at Chicago-based MC+A. This morning, MC+A issued a press release announcing the release of this first component. (MC+A was also our partner on The Findability Project.)

With the public launch of the project, I will begin to post here regularly about the project and detail more about how LSNC is implementing these integrations. You’re gonna like this, people!

  • Tuesday
  • January 11
  • 2011

The LSNC Google API Project

In 2006 Legal Services of Northern California (LSNC) was the first legal services program in the country to adopt the Google Apps platform. Since then, a growing number of legal services field programs and other non-profit organizations have migrated or anticipate migrating to the Google Apps platform to provide staff with a core complement of domain-specific, web-based applications.

The various Google Apps enable users to create, store and share content of obvious practical value, essential to the daily work of the staff who use them to assist their clients, such as: Case-related events created in an advocate’s or office’s Google Calendar; Gmail messages and attachments related to a client case; and case-related documents and files created natively, uploaded for storage, and/or shared with others from within Google Docs.

But therein lies a problem: The content created, stored or shared within Google Apps is not integrated in any practical way with other web-based applications staff rely on to do their work. At the field program level, the most critical gap is the lack of integration of these Google Apps with the program’s case management system.

That’s where the LSNC Google API Project comes into play.

LSNC has received a 2010 TIG award to overcome the lack of integration between LSNC’s domain-specific Google Apps platform and the Pika case management system, the open source PHP-based application in use by LSNC. The objectives of the project are to create practical solutions for integrating select content elements of Gmail, Google Calendar, Google Docs and Google Groups into Pika, utilizing open source design and coding techniques readily adaptable to other open source CMS applications.

Relying on varied Google API options, the project will develop, implement and document the following four, basic use cases for such integration:

  • Integration of Google Calendar functions into the CMS to track date-sensitive calendared items such as filing, hearing and trial dates and other timed or
    scheduled events on client cases, such that they appear and are accessible from either interface.
  • Integration of Google Docs with the CMS, so that case-record-specific documents uploaded to the CMS case record are automatically and seamlessly
    stored in Google Docs, and appear virtually and are accessible in both locations.
  • Integration of Gmail with the CMS, so that an individual Gmail message or entire Gmail conversations related to a particular case can be automatically added to the CMS case record and/or a selected file attachment to a Gmail message can be automatically added to a particular CMS case record.
  • Integration of Google Groups with the CMS, so that discussion group content (e.g., a LSNC welfare discussion thread and/or related file attachments) can be
    automatically added to the CMS case record.

The final piece of this project will be the creation and population of a Google Code project hosting site to host the code actually used. This will help other field programs directly, by demystifying Google APIs, explaining how they work, and detailing the actual code used to integrate Google Apps with a case management system like Pika. Documentation of this project will not be as elaborate an affair as The Findability Project, a few years back. But we will document all the basics along with usable code, so that other organizations with an open source CMS can get grounded and build on what we learn.

  • Friday
  • April 2
  • 2010

Pika and the Google Search Appliance make nice

For those who have followed The Findability Project, I am pleased to report we have surmounted the basic technical problems of targeting our Pika CMS with the Google Search Appliance.

The back story is one I have purposefully repeated whenever giving a presentation about the project, namely, that our Pika Plan A did not work. We encountered code anomalies in Pika that, among other things, cause it to auto-generate new case intakes and case records when it is crawled by the GSA. As a result, we were unable to use the GSA to crawl the Pika client case content dynamically generated as web pages. Plan A would have been the easiest, no-brainer way to go but we were not able to do so. So Plan B was to have the GSA target the Pika MySQL database directly. Status report: Mission accomplished.

There are GSA capacity issues for us, since our particular GSA’s one million “record” capacity means one million web pages or database records, inclusive, and these database records are not the same thing as the count for client case records. At any given time, we may have some 130,000 to nearly 200,000 client cases in our Pika system (and even more in archival data storage), but from a database perspective, these add up to multi-millions of “records,” e.g., various types of time records, case notes, contacts, and so on. Part of the challenge for us was to sort out which pieces of those millions of database records were the ones most needed and useful to our users.

The solution? Using a well-tailored query, we have the GSA do a selective crawl of the Pika MySQL database to return the most commonly sought and used Pika content: Case numbers, client names, office designations and case notes… tons of case notes. The basic technical explanation is the GSA performs a database query, returns it as an XML feed, indexes that feed, against which the user’s search terms are queried and ultimately returned as viewable HTML

What does the the search result look like? A Google search result. The clickable link displays the case number, client name, LSNC office and primary advocate name, e.g., “90-10-123456 ~ John Client ~ Sacramento ~ Jane Advocate.” Below that it displays in-context text with the search terms highlighted in bold, essentially like a regular Google search result. Clicking the link dynamically displays the actual Pika case note shown in context. Assuming there are multiple possible matches for a particular Pika case record, there is a link to display all the “omitted results,” akin to how regular Google searches work, so the users can see all possible, not just probable matches. Clicking through the GSA search result link also gives the user direct clickable access to the particular client case record since clicking through takes the user to the actual Pika client case record.

That’s the name of that tune.

  • Wednesday
  • October 28
  • 2009

Pika 4.0 ~ LSNC customization hoo-hah!

As promised, here is a set of 15 representative screenshots of Legal Services of Northern California’s most recent customization of Pika 4.0. To view a larger image, right click on it and open the image in a separate window. (Needless to say, none of the data field entries in the screenshots are real.) It shares obvious design elements with LSNC’s shared portal, which serves the “news and resource” purpose of the original Pika home page.

Yes, that’s right. Just (mouse) click our Pika home page three times and you are magically transported back home.

  • Wednesday
  • July 15
  • 2009

Summer hiatus

Many months of fish to fry ahead, including bearing down on LSNC’s customized rebuild of Pika 4.0 and working out a solution for integrating our Google Search Appliance. So, laying low until October 1. See you back here this Fall and in early 2010 at the next Austin TIG, when we serve up the whole enchilada.

  • Sunday
  • March 22
  • 2009

Selecting GSA targets – Part Three: Quantification, Revision and Finalization

There is a great deal of work proceeding behind the scenes and several key project elements are converging as we move toward finalizing this public project. Among other things, we have been working through modest but practical solutions for better placement and targeting of our existing 300,000+ repository documents, while solidifying all the additional Google Search Appliance (GSA) targets in our enterprise search sights, described in Part Two. At the same time, we are in our own March (and April and May) Madness as we mount a rapid-fire round of trainings for each of our eight remote offices (spread out over 50,000 square miles of Northern California) on their new role in making Google Enterprise search work for them, which is to say for all of us. And as mentioned in earlier posts, we are working every bit as earnestly on our latest in-house build of the Pika CMS.

The infusion of new, future content into the simplified structural taxonomy we created is a separate challenge we will be posting about later. Dealing with our existing files is more immediate, more concrete. Groking those files has been one of the more interesting, at times hilarious parts of this project.

For those legal services programs interested in how the existing files from our eight local offices break out, here are the percentages for the seven most common “document” types:

  • 67% – WordPerfect (WPD)
  • 18% – Word (DOC)
  • 9% – Portable Document Format (PDF)
  • 3% – Excel (XLS)
  • 1% – Text (TXT)
  • 0.9% – Rich Text Format (RTF)
  • 0.6% – PowerPoint (PPT)

(Discretion prohibits us from detailing the other file flotsam discovered on local office servers. That said, allow us to observe that some within our organization have extraordinarily good taste in photos taken by National Geographic, and not such good taste in music.)

We are totally on track for targeting most of our planned GSA targets: The existing office archive files listed above have long been targeted (although we still have a lot of work left to fit them into our structural taxonomy); over the last several months we have worked very hard to refresh and update (and remove, as warranted) the targeted content at LSNC’s various public websites; and we are very pleased with the quality of the GSA results we are getting out of Google Sites.

This is all good news. In addition, we are putting in place a few more content channels: Targeting the content in our organization’s seven private Google discussion groups, and a program-wide canvass for select hard-copy training resource materials for digital conversion and addition to the shared repository. It’s all good.

We have had one major disappointment: We discovered that there are significant, unanticipated technical challenges unique to the Pika CMS that thus far have prevented effective use of the GSA to target Pika content. The problem is not the GSA itself or configuring the GSA to target Pika. The GSA by design performs wholly benign, non-destructive crawls as it indexes targeted records. We did a huge amount of target testing and SERP evaluation, and we were very pleased — actually, thrilled is a better word — with the results we were getting from Pika. The unanticipated problem is that the current version of Pika is not well optimized for use as an enterprise search target. There are code anomalies in Pika that, among other things, cause it to auto-generate new case intakes and case records when it is crawled by the GSA.

After an assessment by Pika Software, it is now apparent it will take something in the neighborhood of 200 hours of work to make Pika more receptive, shall we say, to an external crawl by the GSA. (Ouch!) So for now, we have to put that part of the project to the side. File under: Lessons Learned.

  • Tuesday
  • February 24
  • 2009

Matt’s Pika 4.0 upgrade guide

This may have dropped below the radar for some Pika shops: Matt Friedlander has posted at PikaDocs his Pika 4.0 Upgrade Guide, a “short walk-through of the process of upgrading your 3.x Pika CMS to the new 4.0 version released at the end of 2008.”

  • Tuesday
  • December 2
  • 2008

Aaron’s Pika blog… and an apology about “text resizing”

Load your feed readers, people: Aaron Worley, PHP rock star and progenitor of the Pika case management system widely used within the legal services community, has announced the debut of the official Pika Software Blog. And next week he promises to also roll out a new version 4.0 with a slew of changes.

Of course, at LSNC we are excited to see a new major iteration of Pika coming out. So, I use this august occasion now to cry uncle and formally apologize to Aaron about all my years of posturing about how text resizing in Pika is a problem because of how its default CSS works.

Hey, Pika CSS works just fine, and I’m sure it’ll be great in the upcoming version 4.0. And all my posturing about text resizing over the years is for naught. All the major browsers now default to full-page zoom rather than text resizing. Even though text-resizing is still an option in some browsers, I now must also admit I no longer even look for it. I have surrendered to full page zoom.

So, Aaron, I cry uncle and apologize. History has vindicated you.

Long live Pika CMS!

  • Thursday
  • November 13
  • 2008

Another Pika design refresh

In no particular order I have posted some representative screenshots of Pika Reborn 2008, an intentionally overstated reference to LSNC’s current experiments with a wholesale rebuild of the Pika 3.07 templates and external stylesheets. (The gallery is flash-based; if you right click an image, you can load a full view of the original screen capture into your browser.)

Working on this modest redesign has been a preparatory exercise for our in-progress updating of our existing version 3.04 install, to fold in the Pika features added since that version, plus integrate additional code changes for custom functionality and modules we want to add to our particular Pika martini. We hope to have our final rebuild completed shortly after the first of the year, and it should look something like this new design. The great advantage of taking a few months to do this “rebuild” experiment is that we were able to try, re-try, adopt, abandon, etc., a number of different solutions for how we want Pika to look and feel and function.

As for the redesign illustrated here, the short version is this:

  • All the Pika structural markup was rebuilt, from scratch.
  • All embedded and inline styles were stripped out of all HTML template and PHP files.
  • All tables used in Pika 3.07 for layout and/or positioning of page elements were stripped out.
  • Tables were retained solely for displaying tabular data, e.g., displaying case lists, search results and so on.
  • All Pika image elements were replaced or eliminated.
  • The default Pika external CSS (cascading style sheets) implementation was dropped and a complete rebuild of external styles was undertaken. This new redesign relies on about 50% less CSS code than was used three years ago for the Project Claire design.

Ya gotta love the Pika. (We do.)

  • Saturday
  • October 11
  • 2008

Rethinking the Pika CMS home page

There are two web projects at LSNC that are moving toward a point of convergence: The most notable of the moment is the ground work we are doing on managing our knowledge content and making it all “findable” via a Google Search Appliance (GSA), which is being documented at The Findability Project (TFP). The other is an in-progress code updating and design refresh of the Pika case management system we have been using with great satisfaction for the last several years, which in earlier iterations we documented at PikaDocs and more recently (and less extensively) here as part of the great and ongoing Pika~palooza.

One of the great lessons we have learned from the whole Pika experience is that our users really like having a commonly shared page from which to begin their work. To some extent, this appetite for a shared page or portal was meet by the Pika CMS “home” page, which we modified by using WordPress to generate a functional, customizable message or news screen. Back in the day, which is to say a mere three years ago, when we did our first customizations of Pika, that modification meant our using WordPress 1.5, a suitable plugin to dynamically convert the native WordPress RSS feed into HTML post content, and recoding a few Pika files to get WordPress and Pika to cooperate with each other. Fun to do, but it was still real work to get it done.

That was 2005. Three years later we are implementing enterprise search and now very consciously building an organizational shared portal to supplant the Pika home page. Simply put, in our next iteration of Pika, which we hope to have in place early next year, what Pika people know as the home or start page of Pika CMS will go away. The functional utility of the Pika home page will be folded into our emerging shared portal, the point of search and entry to many things, one of which will be Pika. (It will take work to do it, but we also expect to supplant the Pika native search function and substitute a subset of our Google Search Appliance functionality to accomplish the same thing, only better.)

To get feedback, we are constantly tooling with varied options for the shared portal as we test things out with different LSNC offices. For example, we have already modified the temporary TFP search portal we experimented with earlier this week in a presentation to our Sacramento Office. After that event, we reorganized things to emphasize the location of the news feed, moving it from the right side to the left, and created a temporary second search field to heighten user awareness of our “Google Sites” special collections. (In final implementation, all our document collections will be searchable from an integrated single search field, with various options for filtering the search results.)

And what about that LSNC “news” thing on the shared portal page?

In 2005 we had to do some attentive coding to get it to work with the Pika home page. Three years later, all we needed to do was pop the native WordPress 2.6 feed into FeedBurner’s totally freebie Buzzboost feature, click on a button to generate a small bit of javascript, past that script code into the shared portal page, and there you have it — an HTML standards-compliant, fully CSS customizable, full-text news module.

  • Sunday
  • February 10
  • 2008

Project Grace 04: “East Bay” 21 Screenshot Salute!

In late December, after posting an earlier version of this post, I realized I was going about this aspect of Project Grace all wrong, so I pulled that original version, a post about “Basic CSS page layout.” There was nothing wrong with the post, but I realized I was drifting toward just repeating myself, essentially a “remastered” series of articles I wrote, quite demonstrably with less knowledge about Pika than I have now, when building Project Claire.

But there were some deeper problems and challenges for me. As I moved ahead with the challenge of doing another CSS makeover of Pika, I was forced to realize (again) that there are really, really severe limits to what one can do with the CSS “presentational” characteristics of Pika because it still labors under a near-decade of seriously dated legacy markup. (In fairness, when we looked at competing CMS options a few years back, all the other developers suffered from this same shortcoming.) While Pika Software did make a serious effort in version 3.06 to clean out embedded and inline styles, with something like a 40-50% uptick in external CSS coding (a good thing), a huge amount of inline styles remain (a bad thing). Pika still relies predominantly on “tables” to control layout and positioning of page elements, which is a good thing for backward browser compatibility and therefore brings a level of presentational predictability in production software. I totally get that. But otherwise it totally sucks.

This is a two-fisted combo that seriously prevents doing much of anything creative with Pika presentational characteristics. Why? Well, inline styles always trump the external style sheet. That’s how CSS works, so your stuck with whatever styles Pika Software embeds inline. And reliance on tables severely constricts the positioning of page elements. Basically, you’re stuck with the Pika default page layouts unless you are prepared to go in and rebuild your templates to conform to more current web standards, something we did with Project Claire, as best as we could at the time.

The other factor that triggered the change in how to approach Project Grace was a meeting Mark Sawyer and I had with some folks from East Bay Community Law Center, who soon will adopt their first CMS ever, namely, Pika 3.06. And I think it is fair to say they’re feeling overwhelmed. (Whew, way understandable to anyone who’s ever been through the process.)

It was during that meeting I got the idea to take the current version of Pika and do simply what I talk about above, i.e., quite literally rebuilding all the Pika templates and subtemplates, regrettably but of necessity still relying on the deeply embedded tables-based layout structures, while removing all the inline styles that remain in the markup. And then modifying minimally the PHP files essential to dynamically generating other specific Pika page markup, principally markup generated dynamically by pika_cms.php and pikaMisc.php. And then creating a totally custom CSS style sheet, all of which works with a default Pika installation. No changes in how Pika works out of the box. No changes in Pika default workflow. Just better, more flexible markup in the templates, some essential tweaks to a few PHP files to get other markup to display correctly, and a fresh coat of paint for the whole shebang via a custom CSS style sheet. And something one could simply upload to the /pika-custom and /css subfolders in one or two fell swoops.

The goal would be to conjure up a simple, clean, low-contrast, uncluttered design refresh. That’s the theory, anyway. So, with Aaron’s recent announcement that Pika 3.07 will be released in another week or so (and Pika 4.0 put off to later this year, at the earliest), the Project Grace approach has changed: Once version 3.07 hits the street, LSNC will set up three Pika 3.07 test beds: first, a virgin reference install; second, an “East Bay” install to build a new set of default templates with a custom CSS style sheet, as described above; and third, a long-form install where we can work on a more radical rebuild to incorporate all latest, way cool Pika Software modifications into all the existing LSNC customizations, something that may take us the better part of six months or so to complete.

What I will be doing here at Webdogs 2.0 is reporting on progress of the second and third installs. Rather than do long-form tutorials, as I have been doing, what I will do is post the rebuilt templates and the custom “East Bay” CSS to PikaDocs in the California Customizations section. These two installs will most definitely be works in progress. The files posted to Pikadocs will inevitably be added, edited, supplemented, and/or deleted depending on what’s happening as the work goes forward. Most likely, I will post select additions to the Project Grace series here to detail distinctive elements of the templates or CSS designs.

Want an early taste? Take a look at the initial set of 21 screenshots of the “East Bay” design now posted to PikaDocs.

  • Friday
  • January 11
  • 2008

Using IE conditional comments with Pika 3.06

This is a repost of an item I added this morning to the PikaDocs wiki. And it has to do with a very unexpected problem we encountered with the recent Pika 3.06 iteration, which implements code changes that unintentionally strip out IE conditional comments from the Pika default.html template. Needless to say, IE conditional comments are a widely adopted, all-but-standardized way to apply IE-only CSS code to control the design or display of web pages. And LSNC has long relied on custom IE-specific CSS code for its Pika redesign. What were CSS hacks like us to do about this dilemma?

Well, sure enough, those PHP-code ninjas over at Pika Software (Matt, to be specific) had the answer:

Open the pl.php file located in the your Pika subdirectory at /app/lib/pl.php. Carefully comment out lines 2055 and 2056 by preceding them with double-forward slashes so that it looks like this:

// $str = str_replace("<!--[", $tpl_prefix, $str);
// $str = str_replace("]-->", $tpl_suffix, $str);

Save the changes and upload the pl.php file to replace it. Now your IE conditional comments code will play nice with Pika 3.06.

  • Tuesday
  • November 27
  • 2007

Elaborating some on global reset and global styles

A few days back I illustrated use of a blunt-force global reset as part of the most recent step in Project Grace. I relied on this purposefully blunt approach to make the perhaps overly dramatic point that resetting all margins and padding for all structural elements significantly simplifies the process of building out one’s CSS for use in most all browsers. And the blunt approach is especially effective for something like a closed, secure Pika installation because it is highly unlikely your actual users (not necessarily your resident IT geekmeisters) rely on any browser other than Firefox or Internet Explorer. We certainly don’t here at LSNC.

But I am mindful of the broader implications of using a global reset, i.e., there are any number of other web browsers or viewers that may be used with your public web content, which is why I referred to Eric Meyer’s au courant article, Reset Reloaded. My current practice for building out CSS on newer public web projects here is to use a modestly trimmed-down version of Eric Meyer’s code, consistent with those structural elements we actually would use in an XHTML 1.0 Strict build, combined with certain “Webdogs” global style defaults.

So, for the record, here are the more nuanced CSS global reset and initial global styles we currently use on all new website builds, with notations:


/*
global resets based on Eric Meyer's "Reset Reload" at
http://meyerweb.com/eric/thoughts/2007/05/01/reset-reloaded/
 */

html, body, div, span,
h1, h2, h3, h4, h5, h6, p, pre,
a, code, em, font, img, strong, sub, sup,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td {
    margin: 0;
    padding: 0;
    border: 0;
    outline: 0;
    font-weight: inherit;
    font-style: inherit;
    font-size: 100%;
    font-family: inherit;
    vertical-align: baseline;
    }
/* remember to define focus styles! */
:focus {
    outline: 0;
    }
body {
    line-height: 1;
    color: black;
    background: white;
    }
ol, ul {
    list-style: none;
    }
/* tables still need 'cellspacing="0"' in the markup */
table {
    border-collapse: collapse;
    border-spacing: 0;
    }
caption, th, td {
    text-align: left;
    font-weight: normal;
    }

/*
global resets per Webdogs defaults;
font-size set per Clagnut's "How to size text using ems" at
http://clagnut.com/blog/348
*/

body {
    color: #333333; /* reduced contrast black */
    font-family: verdana, arial, sans-serif;
    font-size: 62.50%; /* resets 1.0em = 10px */
    line-height: 1.50; /* reset leading for readability */
    }
a:link,
a:visited {
    background: transparent;
    color: #333333; /* reduced contrast black */
    font-weight: bold;
    text-decoration: none;
    }
a:hover,
a:active {
    color: #0000FF; /* blue */
    }

/* prevents inherited shrinkage in Firefox per Clagnut at:
http://clagnut.com/blog/348/ */
li li,
li p,
td p {
    font-size: 1.0em
    }

/* for Firefox where page content < viewport height,
per Zoe Gillenwater's "Create Pages that Fill the Browser with CSS" at
http://www.communitymx.com/content/article.cfm?cid=BAD95
 */
html,
body {
    margin-bottom: 1px;
    min-height: 100%;
    }

Since this is the type of CSS code one is likely to use over and over, consider putting it into a separate style sheet and then use an import rule to pull it into your overall styles for the site. Just a thought.

  • Sunday
  • November 25
  • 2007

Project Grace 03: Rebuilding the CSS from scratch

Where we’re going with the Pika CSS

The first two articles in the Project Grace: Pika Reloaded series were an introduction to several common basic web design development tools, most notably the Firebug extension for Firefox. In practice Firebug has largely supplanted most of the other web design diagnostic tools I had long relied upon, such as the Web Developer Toolbar and the View Source Chart extension.

For example, in the past I often used the View Source Chart extension to generate a wonderfully useful visual display of the underlying HTML page structure. For a Pika-specific example of how View Source Chart works, take a look this visual chart of the Pika Home Page. This type of visual chart is especially helpful in building CSS code since it provides a handy-dandy visual list of all the page elements, their specific id and class attributes, and an easily understood structural hierarchy revealing where the page elements are relative to each other, i.e., which are structural parents, children or siblings. But the ease and convenience of Firebug has changed my web design work habits a lot. Now what I more often do is simply activate the inspection window in Firebug, click on the particular page element I am curious about and go from there, as needed, to diagnose what ails me about the web page design. Which is how I will proceed for the most part as I rebuild the Pika CSS from scratch for Project Grace.

In this article I will briefly explain three things:

  • where the default CSS code in Pika 3.06 is located and how it is organized;
  • how to edit the head tag in the default.html template to remove the default link tags that call the Pika default style sheets and substitute new ones, so you can start from scratch and rebuild the CSS from the ground up with your own custom style sheets that will work in both Firefox and Internet Explorer; and
  • add the first bit of CSS to your style sheets by doing a a “global reset” so that your new CSS code will behave more predictably in both Firefox and Internet Explorer.

How the default Pika CSS code is organized

In a standard web page, one or more external style sheets in the form of CSS files are linked to the web page by using a link tag embedded in the head element of the page. Pika 3.06 accomplishes this by linking the default styles via the screen.css.php file located in the /pika/css subdirectory. View the source code for any Pika page and you’ll see it linked in the head tag at the top:

<link href="/pika/css/screen.css.php" rel="stylesheet" type="text/css" />

The screen.css.php file contains 500+ lines of CSS code. If motivated, you can view the default Pika CSS code. If you do take a quick look-see at the default Pika CSS, you’ll notice that is ordered this way:

  • Basic structural markup elements (e.g., a ... body ... div, etc.) listed in alphabetical order, followed by …
  • id selectors and their descendants (e.g., #auth_label ... #auth_label a ... #bottom_searchbox, etc.) listed in alphabetical order, followed by …
  • class selectors and their descendants (e.g., .de select ... .de input, etc.) clustered into the following 10 categories:
    1. “size” of data entry fields
    2. “specialized” data entry fields
    3. “size” of sidebar fields
    4. “eligibility” fields
    5. “settings” fields
    6. “case list” fields
    7. “alternating table rows”
    8. “masked form” fields
    9. “calendar rows”
    10. “case notes” text format

As we step through the rebuilding of the CSS code, I am going to suggest a different approach for organizing the CSS code. But for now, let’s do some damage.

Creating a custom set of Pika style sheets

The first step I suggest for creating your own custom styles for Pika from scratch is to summarily drop-kick the screen.css.php file out of the mix entirely. To do so, edit the head tag at the top of the default.html template to substitute a new set of link tags that pull in your new styles from three core sources: a “custom” CSS file for your new default Pika styles; one or more IE conditional comments so you can create CSS code that targets only Internet Explorer (for this exercise, I will include one global IE conditional comment; you could add others as suit your needs); and a separate “print” styles sheet that controls how Pika pages print out from within your web browser.

For this stage of Project Grace, here’s what the new head tag looks like with all the new link tags added:

<head>
<meta http-equiv="content-type" content="text/html; charset=UTF-8" />
<title>Pika: %%[page_title]%%</title>
<link rel="icon" href="%%[base_url]%%/favicon.ico" />
<link rel="shortcut icon" href="%%[base_url]%%/favicon.ico" />
<link rel="stylesheet" type="text/css" href="%%[base_url]%%/css/hub.css" />
<!--[if IE]>
<link rel="stylesheet" type="text/css" href="%%[base_url]%%/css/ie.css" />
<![endif]-->
<link rel="stylesheet" type="text/css" media="print" href="%%[base_url]%%/css/print.css" />
</head>

Since these newly linked style sheets have not even been created yet, with these changes made to the default.html template what you will see is a Pika Home page (and other pages) stark naked, i.e., a completely unstyled page.

Create the three new (albeit empty) style sheet files — custom.css, ie.css and print.css and put them into your /pika/css/ subdirectory.

Now you’re ready to dive in with your first Pika custom CSS by performing a hold-on-to-your-butt CSS “global reset.” What’s that you, say? Read on!

Creating a “global reset” for the Pika CSS

Before re-applying any real “styles” to this newly naked Pika page, I want to do a CSS “global reset.” That phrase originates with Andrew Krespanis’ 2004 article Global White Space Reset, the basic theory of which has been famously regranulated by Eric Meyer, the godfather of all things CSS, in his more recent article Reset Reloaded (May 1, 2007). You can review those articles to go deep on the theory.

In an earlier version of this article I suggested doing a blunt-force “reset” by using the asterisk universal selector to reset all margins and padding for all HTML elements to zero. That works, and it is a very common web design approach, but upon further reflection I have decided to rewrite this subsection of the article to promote using a more nuanced global reset, based on Eric Meyer’s model and one that with minor changes I actually use in practice.

The global reset proposed here is essentially the same used here (with some variations) at Webdogs 2.0, as are the added set of initial global styles to control the default appearance of the body, anchor and list item tags. I also am adding a initial global style for image tags to get rid of the border that appears by default in some browsers (including Firefox).

Here’s the whole, initial chunk of CSS code being added to the custom.css. file, with annotations highlighted in yellow:


/*
global resets based on Eric Meyer's "Reset Reload" at
http://meyerweb.com/eric/thoughts/2007/05/01/reset-reloaded/
 */

html, body, div, span,
h1, h2, h3, h4, h5, h6, p, pre,
a, code, em, font, strong, sub, sup,
dl, dt, dd, ol, ul, li,
fieldset, form, label, legend,
table, caption, tbody, tfoot, thead, tr, th, td {
    margin: 0;
    padding: 0;
    border: 0;
    outline: 0;
    font-weight: inherit;
    font-style: inherit;
    font-size: 100%;
    font-family: inherit;
    vertical-align: baseline;
    }
/* remember to define focus styles! */
:focus {
    outline: 0;
    }
body {
    line-height: 1;
    color: black;
    background: white;
    }
ol, ul {
    list-style: none;
    }
/* tables still need 'cellspacing="0"' in the markup */
table {
    border-collapse: collapse;
    border-spacing: 0;
    }
caption, th, td {
    text-align: left;
    font-weight: normal;
    }

/*
global resets per Webdogs defaults;
font-size set per Clagnut's "How to size text using ems" at
http://clagnut.com/blog/348
*/

body {
    color: #333333; /* reduced contrast black */
    font-family: verdana, arial, sans-serif;
    font-size: 62.50%; /* resets 1.0em = 10px */
    line-height: 1.50; /* reset leading for readability */
    }
a:link,
a:visited {
    background: transparent;
    color: #333333; /* reduced contrast black */
    font-weight: bold;
    text-decoration: none;
    }
a:hover,
a:active {
    color: #0000FF; /* blue */
    }

/* prevents inherited shrinkage in Firefox per Clagnut at:
http://clagnut.com/blog/348/ */
li li,
li p,
td p {
    font-size: 1.0em
    }

/* use PRN on DIVs for clearing floated elements,
per Position Is Everthing at
http://www.positioniseverything.net/easyclearing.html */
.clear-fix:after {
    content: ".";
    clear: both;
    display: block;
    height: 0;
    visibility: hidden;
    }

/* for Firefox where page content < viewport height,
per Zoe Gillenwater's "Create Pages that Fill the Browser with CSS" at
http://www.communitymx.com/content/article.cfm?cid=BAD95
 */
html,
body {
    margin-bottom: 1px;
    min-height: 100%;
    }

With this CSS code added, the Pika Home Page still looks pretty naked but now has a few visually distinct characteristics wrought by the new CSS, although the basic positioning or layout of the page elements remains the same. Let’s break it down.

Explaining the first chunk of the Project Grace CSS code

The global reset has already been explained, above. Here’s a brief explanation of how the other new CSS code affects the Project Grace styles at this stage, starting with the initial presentational characteristics for the body element:

body {
    background: #FFFFFF;
    color: #333333;
    font-family: verdana, arial, sans-serif;
    font-size: 62.50%;
    line-height: 1.50;
    }

The body element is reset this way so that the background is white (#FFFFFF), the color of text is set to a lower contrast black (#333333) to enhance readability, and the basic font-family style is declared (verdana, etc.). The font-size is set to 62.5% to make it easier down the road to set alternate font sizes for other page elements that inherit this value from the body element. (For those who want a preview of the explanation for resetting the font-size this way, take a look at Richard Rutter’s highly influential article How to size text using ems. And for even more on this topic, you may want to read Richard Rutter’s more recent article published at A List Apart in which he updates his take on other approaches to assure cross-browser consistency in how text size displays. Here, I’m going to go with what I know until I can digest his latest musings on this subject.)

The line-height value is set to 1.50 to make the text, again, more readable. (Typographers refer to this as leading or line spacing). If you’re wondering what’s up with the “unitless” value for line-height, I refer you to Eric Meyer for the explanation. Me, I just do what Eric Meyer tells me to do. You would be wise to do so also.

Here is how the anchor tags are styled at this early step in Project Grace:

a:link,
a:visited {
    background: transparent;
    color: #333333;
    font-weight: bold;
    text-decoration: none;
    }
a:hover,
a:active {
    color: #0000FF;
    }

The anchor or “link” tags are set exactly as they are here at Webdogs 2.0. The declared values for the CSS properties override any browser defaults for displaying linked text by establishing their default color as the same used in the body tag, but in bold so that they stand out against a transparent background (assuring that the background of any other page element shows through), without any text-decoration to get rid of the “underline” displayed by default for anchor tags in all browsers, and a “hover” state that changes the linked text to blue (#0000FF).

Why do it this way? In my judgement it is a mixture of both design and readability issues, the thought being that removing text-decoration makes actual reading of page text with links easier. We have been doing this for years at both LSNC.net and, of course, here at Webdogs 2.0 without any complaints or apparent confusion by users. None. Experience tells us it works and is actually more user friendly. (Needless to say, others would beg to differ.)

Because list item tags are the semantically correct way to build not only actual lists of things on web pages but also itemized horizontal and vertical elements, such as horizontal navigation and sidebar menus, the default for ordered and unordered list items is reset to not display any list-style, such as a bullet or disc:

ul, ol {
    list-style: none;
    }

To get rid of the blue border that appears by default around image tags in some browsers, you do so by globally nukin’ it with a none value:

img {
    border: none;
    }

Finally, one common problem associated with different browsers is how they deal (or do not deal) with inheritance of font-size from some parent elements to some embedded child elements. This is a problem of inherited shrinkage triggered by the cascade effect of CSS that occurs inconsistently among browsers. Anyone who has had to tweak font-size to address inconsistencies in the text size of a sublist of item children embedded within a parent list knows of which I speak. Aaaaargh! To deal with that problem not only with list items but also paragraphs that are the children of parent list items and table data cells, the following CSS code is used:

 /* prevents inherited shrinkage */

li li,
li p,
td p {
    font-size: 1.0em
    }

Alrighty, now! True, the Pika Home Page doesn’t look like much at this early stage of CSS tweakery. But a solid “reset” foundation is in place as we stage for more visible changes to come. Reason enough to return for Project Grace 04, wouldn’t you say?

The Whole Enchilada: Project Grace: Pika Reloaded

  • Sunday
  • November 18
  • 2007

Project Grace 02: Basic HTML and CSS deconstruction

Consider this article “basic orientation.” The focus here is to detail how to get a handle on the basic structural design of a Pika page and where the cascading style sheet (CSS) code resides within the current version 3.06 of Pika. I will rely on some of the web developer tools described in Project Grace 01: Get your Firebug on to demonstrate how to do that.

The first sacrificial lamb in support of Project Grace is, predictably, the Pika Home Page. Out of the box here is what that page looks like:

Understanding the underlying structure of the Home Page

Let’s do some basic deconstruction. Using the Web Developer Toolbar, select CSS > Disable Styles > All Styles. Now the Pika Home Page displays stripped of all its custom CSS presentational characteristics. What you see is how your browser by default displays the page’s HTML structural markup in the same order as the markup appears in the “flow” of the underlying web page:

Looking at this page “naked,” even without looking at the actual markup behind the page display, those familiar with basic web page design will notice that the underlying structure of the page relies on tables, rather than CSS, to control the basic layout of the page. The three apparent columns in the middle (“Frequent Tasks,” “Message Board” and “Learn to Use Pika”) are dead give-aways. Again using the Web Developer Toolbar, to confirm this observation select Outline > Outline Tables > Tables, revealing that the page uses a table at the top for the “header” area, below which is a second table for the “middle-content” area:

To see the table cells that control the three columns in that middle-content area, select Outline > Outline Tables > Table Cells:

Since this stage of Project Grace is an attempt at a benign CSS makeover of the default Pika 3.06 presentational design, I will refrain from my usual rant about the misuse of tables to control page layout this way. At the very least it is not optimal. It’s OK and it works and, admittedly, it assures backward compatibility with now generations-old web browsers. But with the advent of increasingly CSS-standards compliant browsers, including IE7 (much improved) and Firefox 2.0 (way better), such design approaches are increasingly harder to defend. But I digress.

The final structural piece is the page “footer” at the bottom. To see what that’s all about, let me show you three ways to Sunday using three different tools to figure out that bit of markup.

First, make sure you have refreshed the Pika Home Page to get rid of the any earlier selections you made using the Web Developer Toolbar and you can see the default Pika page design again. Good to go? Now select CSS > View Style Information. Then scroll down to the bottom of the page where the “footer” is located and hover — but don’t click — your mouse (which changes into a cross-hair) over that area so that it is highlighted with a thin red border:

If you look up at the Web Developer Toolbar, it has opened a new information box immediately below the toolbar itself, revealing the underlying structural hierarchy for the highlighted page element, including the name of any id or class attributes:

(I will explain below what else happens when you click on the page element using this feature.)

Second, try using the XRAY bookmarklet. Click on it and then click on the footer area at the bottom of the page. (You may need to experiment with where you click to get results for the entire footer element, rather than other elements embedded within it.) The XRAY box displays basic information about that page element: It’s a div with an id attribute named “footer” and the inheritance hierarchy is html > body > div, all essential and useful information for working with CSS:

Third, let’s give Firebug a shot at this. Activate Firebug and in the Inspection window pane select “HTML” and then “Inspect.” Hover your mouse over the footer area to assure you have selected the whole footer area (you will see the blue border change so you can see which area is active within the Firebug inspection window), and then click the area to select it:

In the left pane you will see the “footer” div highlighted, as well as the structural hierarchy of that page element revealed, i.e., html > body > div.

Locating the CSS code

Here are a few ways to figure out where the CSS code is for any Pika page:

Be sure to close out Firebug and refresh your browser window. You should be back to the default Pika Home Page design. Using the Web Developer Toolbar, select CSS > View CSS. This triggers a new page listing all embedded CSS styles followed by the file location and contents of all external CSS styles affecting the presentational characteristics of the page. (As far as I can tell, this feature in the Web Developer Toolbar does not reveal inline CSS styles.)

When you invoke this feature, you’ll see that all the basic CSS code is located in the Pika CSS subdirectory at /pika/css/screen.css.php. Conveniently, the CSS file location is linked so you can open up the CSS code into a separate web page for review. For locating the CSS code specific to a particular page element, select CSS > View Style Information and then click on a page element. For example, if you click on the footer element discussed above, you will see the CSS code illustrated to the left.

Another way to go is to use Firebug to locate the CSS file location and the CSS code that relates to any selected page element. I am not going to repeat so much how that works, detailed here in the prior article. Suffice it to say that if you invoke Firebug and from the inspection window select HTML and Inspect, and then click anywhere on the page, you will see in the right pane the corresponding CSS code and where the file is located containing the code, illustrated here to the right and highlighted in yellow. The CSS file location is clickable, so if you want to get the whole CSS enchilada, not just the code for a particular element, go ahead and click it and Firebug opens up the whole CSS file in the Firebug window. Nice.

The effort here has been to suggest several different ways to deconstruct Pika pages to give you the basic information you need to restyle its pages elements. On balance, I prefer using Firebug for both the HTML and CSS excavation processes described above. But that’s me. There is more than one route to the mountain top and you now know where several of those paths are to your innner HTML and CSS geek.

You’re oriented. You’ve got a handle on the basic structural markup of a Pika page. You know where the CSS code is located. You know how to zone in on the CSS code for any particular page element using various web developer tools to extract that information. Time now to do some Pika CSS style rebuilding, the whole point of this first stage of Project Grace. Onward to Project Grace 03: Rebuilding the CSS from scratch!

The Whole Enchilada: Project Grace: Pika Reloaded

  • Sunday
  • October 28
  • 2007

Project Grace launches. Really.

Photo of Grace Mae Lawlor

Talk is cheap. Last June with Pika 3.06: Reloaded I talked up about Project Grace: The Pika Love Project, followed it up with a few initial experiments with Pika 3.06 table sorting, but then work on our next in-house iteration of Pika got stalled some. But Pika Software has given us a good kick in the butt to move forward again, with its recent release of the 2008 LSC CSR Module and the updated public demo of its latest Pika iteration that includes the new CSR module. (Want to try the demo? Login using “guest20″ for both the username and password. Enjoy!)

As we move ahead there may be more “stages” to LSNC’s next round of work on Pika but I can describe at least two of them here and now. Stage One of Project Grace should unfold fairly quickly over the next few months. It will be a modest series of lab tests to see how far we can push the default Pika 3.06 page layouts, page-element positionings and other presentational characteristics by working Pika’s newly implemented cascading style sheet (CSS) controls. Stage Two will go way deeper as we build a revamped and updated in-house version that incorporates all our customizations while exploiting the functional changes made by Pika Software in its latest version.

But back to Stage One and the new Pika cascading style sheets: What? You didn’t know that Pika Software had quietly changed how cascading styles operate in version 3.06? Neither did we until we started tinkering with them. Not to worry, the earlier-version danio.css style sheet and others are all still there in the default /css subdirectory and available for legacy Pika installations that need to fall back on the earlier presentation of page elements (as opposed to their structural markup) generated by the old CSS files and other styles embedded in earlier versions of HTML page templates and PHP code. You’re still covered, people! What Pika Software has done, and correctly in our view, is move more and more of the presentational characteristics of the application to external style sheets. In this latest iteration that translates into PHP coding that relies on the _screen.css.php file to handle all the basic style elements in this newest version. Where is the _screen.css.php file? It’s right there in the /css subdirectory with all the legacy CSS files.

With that clarification in hand, as we move through Stage One of Project Grace I will for the most part refer to the CSS-specific code lines in the _screen.css.php file to demonstrate how changes made there in the CSS coding can be used to add, remove, toggle and modify various presentational characteristics of Pika 3.06. The goal of Stage One is simply to learn where and how the current Pika 3.06 style characteristics reside and can be changed. I will not be changing any of the structural markup or page templates at this stage. I do reserve the creative prerogative to tweak a few lines of PHP code elsewhere within Pika should I discover it must be done to control the presentation where Pika Software has embedded a particular element’s style inline. Other than that, I will make every effort to avoid it.

Also, I will use this Stage One exercise to demonstrate a handful of Firefox-centric web development tools that may be helpful to others who are game to tool around and tweak their Pika styles, if not other things. One of my favorite sites, the How-to Geek has a post describing a slew of worthwhile Firefox web development tools. Here is a smaller, more limited collection of Firefox add-ons (including a few not mentioned in the How-to Geek article) and a few web development bookmarklets I will likely refer to or demonstrate in this series of articles:

You can do what we’ve done: Set up a test-bed default installation of Pika 3.06 that you can live with blowing up if it comes to that. Make sure you know where the Pika CSS subdirectory is and have FTP access so you can download and upload your file changes. Load up all the Firefox add-ons you need. Keep your favorite HMTL and CSS resource at hand for ready reference. And then keep your mouse up and your head down and let’s see how this all turns out.

“Project Grace: The Pika Love Project … A post a week. It’s all we ask.”

See you next week for the first chapter.

  • Wednesday
  • July 18
  • 2007

Pika 3.06 ~ CSS Matrix: Once more, with feeling

With a few more tweaks and a 100+ more entries, I have compiled a final version of the Pika 3.06 ~ CSS Matrix, with 238 entries sortable by HTML or PHP file name, markup tag; or id or class attribute.

And the point is…?

The first point was the original point, namely, to play with creating a sortable table. To coin a phrase, “mission accomplished.”

The second point was to go through the exercise of deconstructing what was done with Pika 3.06 to remove embedded styles from the application. It was fairly easy to do. With the Pika HTML templates, all it took was setting up a few basic search queries for character patterns that would lock in on id and class attributes in the structural markup. All I did was go through each of the HTML template files, do the queries, and plopped the results in the CSS Matrix table. In each instance, it only took a few minutes. Culling this same information from the PHP files was a little more demanding because my initial queries revealed how deeply and widely the Pika PHP files have so may pockets of code with embedded tags and attributes that are legacy or commented out or whatever, with no real connection to the current default Pika CSS files. So I took a different tack: I worked backward from the CSS files, searching the PHP files for any attribute referenced in the style sheets. This simplified the search to tags embedded in the PHP files with attributes with a connection to reality, i.e., ones affected by the CSS code in the danio.css and other style sheets. For purposes of the CSS Matrix, any other attributes were irrelevant. The 238 entries listed are all the ones I could find.

The third point is where I am going with this as part of LSNC’s various Pika test beds. We currently have four Pika installation:

  • The real Pika install used by all LSNC staff.
  • The Pika test install which duplicates the real install exactly, where we can test modifications and risk things blowing up before we fold changes into the real install.
  • A virgin copy of Pika 3.06, essentially a reference copy of the current iteration so we can readily access an untouched copy of the current code and see it function as Aaron intended.
  • And the Pika makeover edition, where we can experiment with our ideas for our next internal build of Pika.

One of the first sets of tests we will be doing with Pika 3.06 is to test out its new custom template functionality so that we understand how it works and can get comfortable with it. As part of that we will be using the CSS Matrix as one of the tools to mess with the Pika styles. It will be fun to see how hard we can push the boundaries of the presentational characteristics of Pika out of the box, only using the Pika style sheets. That’s where the CSS Matrix comes into play.

We’ll get back to you about that in a few weeks, provided the patient survives our tinkering.

  • Saturday
  • June 16
  • 2007

Pika 3.06: Reloaded

“The past is but the past of a beginning.” ~ H.G. Wells

For those paying attention, the second blog ever posted at Webdogs 2.0 was about the Pika 3.06 beta. (The beta test site linked there is no longer active.) That was then. (October 2006, to be exact.) This is now. Last week Aaron officially released the full-on version of Pika 3.06.

As you can see from the accompanying imagery, Pika has discovered gradients and has undergone a modest but appealing makeover, with updated colors and page elements. The case tabs have a new, spiffy 3-D look. And the Pika home page links directly to recently updated online Pika resources at the famed PikaDocs wiki, including the Pika User Manual and Pika Admin Manual.

Going deeper, Aaron has recoded things to make it way easier for organizations to maintain control of their (inevitable) customizations. Long time Pika-savvy ITs know all too well that, for example, the page templates for the older versions of Pika are located in the /templates and /subtemplates subfolders, and with every upgrade you had to be very careful and re-code the individual customized templates (or other customized files) to add in the new Pika coding. One could not just copy the new files over the old. No way.

But with this new version, actually you can! Here’s how it works in the new Pika 3.06: Aaron has recoded Pika to exploit a new special custom folder where you can place templates, subtemplates, tab customizations, modules and configuration files. Those are yours, and all yours. With those in place, Pika 3.06 automatically checks your installation to see if you have created a customization located in that special folder. If it sees that you have, Pika uses your customized file instead of the Pika default file. Sweet.

Among other tucks and tweaks that come with the new version are a major (if not yet complete) move towards removal of embedded style elements, pushing more and more of the presentational characteristics of Pika to external CSS. Pika 3.06 also includes improved report printing, courtesy of newly exploited CSS features that permit differing display of a web page in the browser and in print. The old option for printing reports as HTML or PDF is gone. The new approach is better implemented, relying on standards-compliant CSS print style sheets, so the user can see the report displayed in a web page or in a conforming “print” style to your printer or to a PDF file format, which in practice is essentially a print format. This is a singularly great improvement for all Pika users.

And since I’m on the topic of CSS, allow me to digress a bit about my present befuddlement about text resizing in Internet Explorer. Unlike all other browsers, IE does not resize page text if it is set in pixels, which is exactly what Pika 3.06 does, and has done in its earlier versions. (The Pika default body tag is set to “font-size: 13px” in the danio.css file.) There is irony in the fact that I have hammered Aaron on this point for the longest time but now I rarely use IE having joined the Firefox cult. But hey, on principle it matters! All users should be able to resize text within their browser. Yes, IE7 has a “zoom” feature but that is not the same thing as text resizing. Yet apparently in the current version of IE7 that is exactly what Microsoft, misleadingly, calls it when you select View > Text Size. Actually, what that option in IE now does is trigger the zoom function enlarging not just the text but all the other page elements on the page. Try text resizing in IE7 (which adopts the same Ctrl++ and Ctrl+- keyboard shortcuts used by Firefox for text resizing) and then view the same page doing the same thing in Firefox. Watch in IE as your text enlarges but also your whole page structure expands off to the right and the bottom of the page. Watch in Firefox as text resizing enlarges or shrinks the text but honors the page structure. Zoom has its functions, but it is a notably less effective way to allow users to granulate the size of page text to ease readability, while maintaining the basic layout and proportions of the page structure. This is a real stinker/cheat of an implementation in IE.

Now, back to our regular programming.

I spoke to Aaron a few days ago, and he reports the pace of the Pika development cycle, with its promise of Pika 4.0, will be picking up. Pika Software used to do customizations more when the Pika install base was smaller, but as things have grown he has shifted his focus more purposefully on full-on development and now refers customizations out to those open source savants over at Kaivo.

So, where does this leave the Webdogs? We can’t wait for Pika 4.0, but in the interim we’re going to do a lot with Pika 3.06. We have already set up a test bed and will begin to migrate our heavily customized version of Pika over to pull in all the new goodies. In the process we will begin to build yet another Pika redesign to build on all we have learned from our initial two years of experience with Aaron’s code. What this means for Webdogs 2.0 is that the long nascent Pika~palooza is back on, full on. Forget Project Claire. She is soooooo 2005. Get ready for Project Grace: The Pika Love Project.

  • Friday
  • April 20
  • 2007

OpenPika ~ R.I.P.

OpenPika.org

A brief notice and a moment of remembrance for OpenPika.org.

Today we shut down the OpenPika server. URIs targeted at any of the multiple OpenPika domains henceforth will be redirected to the Webdogs 2.0 site. OpenPika was one of Legal Services of Northern California‘s earlier blog sites, back in the day (OK, only four years ago) when we started experimenting with various blog publishing platforms like Blogger and Movable Type, and eventually settling on WordPress as the open source publishing platform of choice. The OpenPika web road show ran for 22 months, from August 2004 to May 2006, as a long-form experiment in using a public web presence to provide both information and transparency to our staff and the larger legal services community about LSNC’s work in preparing for a long overdue transition from its out-of-date, decentralized, desktop-based case management system to the web-based, web-centric and wonderful Pika CMS. As best as we could, we documented and invited comment on what, how and why we were doing what were doing with Pika, which we heavily modified and pretty-fied but with abiding regard for Aaron’s solid core coding. We learned a lot in the process, and we hope we were helpful to those who visited and used the OpenPika site and the content we added to PikaDocs over the life of the site. If Webdogs 2.0 has any value, it is because OpenPika.org taught us how to do some things better.

OpenPika. The stuff of which memories are made. And they are all good.

  • Sunday
  • February 4
  • 2007

Preppin’ Pika for 960

That would be 960 pixels. Let me explain.

In 2005 when LSNC began to build out its initial redesign of the Pika CMS, the design was premised on the prevailing horizontal scale for a web-based user interface, namely, a 760px fixed width for display in an 800-by-600 viewport. Our redesign conformed essentially to the production version of Pika that, quite sensibly, is built with a fixed width to assure that the full width of the UI displays as intended, without any need to scroll horizontally, at least for the vast majority of desktops. (Sure, one could build for a 640 by 480 pixels display if you have users with 13″ or smaller monitors, but if that is the case, well, it is likely your organization is simply not ready for web-based applications of any kind. Really.)

And this made practical sense at the time because the universe of monitor displays within the legal services environment, or at least in ours, was predominately 15″ CRT displays set at 800 by 600 pixels, with a replacement cycle moving toward 17″ LCDs set at 1024 by 768 pixels. While we could have initially built a design that was more forward looking, for those users with a bigger piece of viewport real estate, the reality on the ground was that the overwhelming majority of users were living their lives at a more modest display scale. So we built out our version of Pika to a fixed width of 760px, which allows adequately for browser chrome in both Firefox and Internet Explorer, with no need to scroll horizontally provided the user maximizes the browser within the viewport. Users working at 1024 by 768 pixel got the full UI display, of course, with a nicely textured background on the left and right sides of the UI. A touch of sauce béarnaise to go with the steak, so to speak.

But that was then. This is now. And by “now” I really mean 2008. As mentioned earlier, once Aaron releases Pika 4.0, the Webdogs team will set up a test bed for the new version, mount a full-on assault on his new templates, and begin to build out Project Grace. And that project redesign will build out to a fixed width of 960 pixels, for display in a 1024-by-768 viewport. This second redesign of Pika will not be nearly as daunting as our first go around, since the Webdogs now pretty much know where everything is in Pika and how the basic template structures work. The goal is to have the Project Grace redesign ready to hit the ground in early 2008.

This discussion, of course, begs the question, “Why 960?” Here’s how we’re looking at it:

First, I’m know I’m preaching to the choir on this now obvious point, but the web world view(port) is already predominately a 1024-by-768 world. The debate over whether there is a need to design to 1024 is largely over. Apart from reading web design articles, how do I know that? Because even the populist LSNC main website tells me that the world of 800-by-600 is in steep decline. Here is the Google Analytics graph on screen resolution of our main website this last week:

Screen resolutions of viewers at LSNC.net

Sure, 800-by-600 is ranked second but only so with less than an 18% share, and I guarantee you that number is going down incrementally month by month. Every other screen viewing our public site is set at 1024 or wider. That’s an 82% share and growing. And the LSNC percentage exceeds the web-wide percentage identified by others. (For what it’s worth, the percentage of screens set at 800-by-600 viewing Webdogs 2.0 in the last week was zero, zip, nada. No surprises there.)

Second, we’ve run an inventory of our monitor stock, and we think we’ve hit the proverbial tipping point. With a modest amount of capitalization, combined with our regular monitor replacement cycle, by early 2008 we should have all our desktops positioned to take advantage of a 1024-by-768 viewport. True, there will undoubtedly be some hold-outs who simply won’t want to change and will hang on to 800-by-600 viewports. And if they want to scroll horizontally, that’s their choice. That quirky reality is not a rationale for holding the rest of the organization back. When the hold-outs are ready to move to 1024, Pika will be ready for them.

Third, less is more. Step back from the whole UI construct for a second and think in a broader design sense. There is a reason why an uncluttered display of information in any setting is “easier” for one to view or scan. It relaxes the eye and it is easier to locate objects in one’s view. This is why good typography, including web typography, demands proper leading (line spacing). Booksellers refer to this concept as “space sells.” Been in a Wal-Mart lately? Compare their display philosophy with that of your local Target. I rest my case. So, more pixel width means more available space between screen objects. Which means tangible gains in usability.

Fourth, more is more. A corollary here is that more space means that selective screen objects can be scaled larger, e.g., label text, input fields, buttons, and so on. As can basic text. And the option to do so is also a usability and accessibility issue. With Project Claire we postured a lot about making text display more scalable. One criticism we had of Pika was it’s reliance on a default font setting in pixels, which were not resizeable in Internet Explorer, rather than ems or percentages, which are. (Full disclosure: Aaron has promised to fix this in his upcoming iteration.) But we never quite got the Claire design to where we wanted so it could readily scale at least a bump or two up without breaking the layout or positioning of some page elements. But going to 960 will give us an extra 200 pixels of width in the Pika user interface, and this is a huge thing. How much so? It is equivalent to having an entire additional vertical menu column available for use on a typical web page. Take a look at the vertical menu on the right side of every page here at Webdogs 2.0. It is less than that, only 178 pixels wide. This is some serious real estate we can most definitely exploit.

What does a 960 pixel fixed width look like? You’re looking at it right now. Webdogs 2.0 itself is a web laboratory experiment, which like OpenPika will some day be put down. But when we built it, we did so with the forward notion that we could use the site to generally test out better, more compliant markup and CSS, and more specifically how that would work best with a wider page display. So far, things look damn good at 960.

  • Sunday
  • December 31
  • 2006

Pika~palooza 2007

We’ve spent the last calendar quarter getting our legs here at Webdogs 2.0. Now, with all the apparent site bugs worked out — anything here not working or displaying correctly for you? — and with a modicum of post content in the can, we will shift our focus increasingly on building out the major content areas inventoried on the right-side menu. Most notably, we will begin to give attention to where LSNC is with the Pika CMS. Here’s what’s coming up in the months ahead:

  • Pika Lessons Learned: With a long-form narrative at OpenPika and a high-volume posting habit at PikaDocs, LSNC from August 2004 through May 2006 engaged in an institutional experiment in technology transparency and accountability. We called our initial Pika development cycle Project Claire and let LSNC staff, the Pika community as a whole, and the larger legal services community watch as we thrashed out the details of evaluating, adopting, modifying and then deploying a entirely new (for LSNC) web-based case management system. And you ask, “Well, how did it go? What worked? What didn’t work?” We will begin to answer those questions here.
  • Pika 4.0 = Project Grace – Like others in the larger Pika community, we are cooling our heels as we await Aaron’s release of the next version of Pika. The moment it is released we will be setting up a test bed and will begin to twiddle, tweak, and tear apart if necessary his revamped template system as we integrate Pika 4.0 into our current version. We’re calling it Project Grace. Predictably, we will write about that here, and we will document what we are doing at PikaDocs. Why? Because that is what we do. It’s the Webdog ethos.
  • Valid ≠ Best Practices – Truth be told, despite all the “validation smackdown” posturing here at Webdogs 2.0, we are not such dumb mutts that we think “valid” code is “optimal” code. As Roger Johansson wryly observes, validity does not equal best practices. Yes, all our Pika templates rebuilt for Project Claire nominally validated. But the Webdogs are where they are now, not where they were when they began that project, and there is one certitude we have come to know in the interim: the Project Claire templates are OK, but they are not remotely optimal. Building on the new Pika template system, we will undertake for Project Grace yet another full-on structural markup makeover. We promise new model templates with more sensible markup that is valid and semantic and accessible. You can count on it.
  • Optimal Pika = Pika Usability – Among other things, we are working on tweaks to our initial intake workflow, enhanced file attachment integration in case records, improved data “findability,” and other usability enhancements. As we work these elements up, we will detail what it is, where it is, and why it matters.
  • Bottom line – It’s all about Pika love.