Implement a versioning system on style plugins that allows the legacy
renderer to determine what type of data it should be passing to style
plugins.

Docblock touchup.

Fix ajax refresh of panes.

Deindent the main body of the js; major jQuery plugins do not indent
within the body of the $ alias checker as it's silly.

Fix docblock typo.

Refactored the pane rendering to use only one method. Also fixed a
missing return that was causing nothing to be rendered at all.

Keep up with changes to the default renderer, and observe separation of
phase responsibilities best practices.

Change the default renderer's build() method to take only a single
parameter, as that's more inheritance/interface friendly.

Renamed files in accordance with class name change.

Renamed 'panels_renderer_standard' to 'panels_renderer_default', as
default is at least as accurate, but is more common and doesn't have
some of the additional meanings 'standard' does.

Big documentation update.

Removed all TODOs from the legacy renderer, as it will not be evolving
any further; any TODOs apply to the standard renderer, or not at all.

JS cruft removal.

Move the single pane renderer into the set of display renderers provided
by the main Panels module, as nothing about it is actually specific to
IPE.

Fixed ternary empty() typo that was causing nothing to render at all.
Whoops.

Add the $renderer parameter to panels_render_display() for passthrough
to the render method. I swear I've added this at least twice before, and
it keeps disappearing...

More consistent, clearer variable naming: $region_id now refers to the
system name of a panel region, and $region_title refers to the
human-readable name.

Refactored the IPE renderer to take advantage of the standard renderer's
now-extendable design; initial work towards a better system for placing
the 'add new pane' button, and placeholders for empty regions.

Docblock touchups.

Attempt to render prior to setting the edit cache. This prevents panes
that cause fatal errors to fail more safely.

More refactoring of the display renderer. Region settings prep/expansion
is now entirely moved into the prepare phase.

Variable name typo fix.

Forgot to remove a dsm(), whoops!

Docblock updates.

Initial refactoring of the render pipeline to be more compartmentalized,
and therefore friendly to friendly to modification in child classes.

Changed AJAX responder to use slightly more correct (though still wrong)
jQuery target

Moved all display renderer plugin definitions out into separate .inc
files.

Moved display renderer plugins into separate classfiles

Turned off mad-hack to make the IPE renderer always be used; also made
it possible to pass a renderer in to panels_render_display().

Forgot to include default-setting logic for the ipe setting

"fixed" the already-sent-headers error, though I don't really know
what's going on well enough to do a proper fix.

Major step-up in the default perms required for accessing the IPE. This
will have to be significantly revisited later, but binding to page
manager permissions is safe, and therefore sufficient, for now.

Initial rudimentary page manager integration

More minor touchups

odds and ends; got the handlebar to show up on newly-added blocks

Markup modification; hardcoding now clearly delineates the portlet
content from the wrapper and the theme/plugin-generated markup

Re-added the delete binding to behaviors

Wrong format for the dependencies

Got rid of old @render tags

Cleaned up disorganized commits of changes into teh wrong files from
last commit. Hmm...must have gotten too much beer from drewish.

Legacy renderer now mostly back in shape, and panels_render_pane()
restored with its original functionality.

Credit for this patch goes 100% to drewish for getting me beer.

Initial copyover of code for the legacy renderer

Minor js cleanups

Changed 'outermost' property to 'topParent'; hopefully a little more
self-explanatory

Forgot the rather important jquery_ui dependency

CSS and markup tweaking (credit primarily to squiggy), and some other
assorted bits.

Submit works!!!!!!!

Using a more unified, saner set of classes for IPE element display
toggling.

Much progress towards getting the controlling js object fully working

Forgot to add the updated class name

Reorganized IPE object logic; now designed to persist a single object
through multiple editing start/stops, as needed.

Added one more layer of wrapping markup, this time at the super-layout
level (i.e., wrapping the output of the entire panel display)

Forgot to actually return the form back to the AJAX call

Got rid of stupid "capacity" for capturing multiple IPE forms in the
footer - simply zero likelihood that the IPE gets extended in that kind
of way

Begin moving initialization logic down into the object definition

Stupid existing built-in dnd css has polluting padding...temporary
override

Basics of hiding the additional IPE elements initially, and the proper
animations for revealing them on the AHAH response

Basic form insertion is working, though it still needs attaching in the
right place.

Removing gibberish...kitty on the keyboard?

Minor whitespace removal

Another incremental commit towards the form controller & wrapper.

Incremental commit of work on the controller form

Fixed @todo; panels-ipe-proper-pane class is now added by behaviors.
Note that the approach is hacky and inefficient, and should be improved
later.

demo, fugly, unthemed version of an 'add new pane' button now included

Edit form AJAX/modal is working.

Moved to-be-modified AJAX callbacks out from display-edit.inc.

Incremental refactor of the js, towards a separate, bind-able standalone
class.

Also added the renderer & menu callback for a single-pane render.

Other minor touchups.

Render method didn't actually support passing in the string name of a
renderer class, as it should (and as the docblock indicates)

Fixed docblock.

Accidentally left in whitespace, as well as some testing cruft.

Now firing into an object cache and capable of retrieving modal forms.
Gonna take a lot more elbow grease before it all lines up, though.

Basic draghandle now working

Basic functionality is working.

While it makes sense in retrospect, jQuery UI's sortable takes care of
generating its own draggable & droppable logic - a fact that's doesn't
seem to be presented quite as up-front as it ought to be!

Initial commit of very rudimentary DND (mostly placeholders, not
actually functional)

Catching up with the panels_render_pane() changes in the pipeline; now
calling a theme wrapper on processed pane output to allow arbitrary
wrapping around it.

Moved panels_render_pane() further up in the render pipeline.

This is a major change, though one that shouldn't affect any existing
Panels implementations (unless they're using region styles in a totally
unanticipated way). Rather than having style plugins with region support
call panels_render_pane() themselves on a pane content object, this
change moves that logic further up into the render pipeline and simply
passes the regions an array of already-rendered/styled/themed pane
output.

Initial commit of the in-place-editor module.

Some final tweaks to get the display renderer working correctly.

Added hook implementation for renderer plugins

Whoops, left in an empty method + call that borked the whole render
stack.

Finish cleaning out panels_display_get_title()

Removed the now-obsolete panels_render_panel() function, and updated
relevant docblocks.

Removed now-obsolete panels_get_pane_content() function; collapsed that
logic with its old wrapper (panels_render_pane()) into a single method
on the renderer for readability.

Removed the now-obsolete panels_render_pane_content() function, and
updated appropriate docblocks.

Removed the now-obsolete panels_render_panes() function, and updated
respective docblocks.

Removed the now-obsolete panels_render_layout().

Removed the now-obsolete _panels_render_display()

Replaced panels_display_get_title() with method from the object

Added caching todo note

Small refactor to make renderers more easily swappable.

A few small tweaks. The renderer now officially works.

Changes that make the new display renderer plugins actually get used.

Forgot to move the .inc file to reflect new plugin and class name.

Title retrieval really makes more sense to have right on the
panels_display object.

Changing from top-level object polymorphism (display controllers) to
encapsulated polymorphism (display renderer). Though the core effort
should probably employ top-level polymorphism, encapsulation is fine for
the current purposes, and makes backwards compat a LOT easier.

Minor comment cleanup.

Initial commit of the panel display object, moved into a plugin.

Panels stylizer should show up in the Panels package

Updated CHANGELOG for release.

Restored (and deprecated) panels_print_layout(), as other modules were
relying on it.