Hi Xueqing,

If I haven't been clear before this, thank you for your interest in this
project. The non-linear writing enhancements have been a passion project
of mine for quite some time. I am excited that there is another person
interested in them and look forward to working with you toward their
completion.

In this email, I am going to try and lay out their current status, next
steps, and offer recommended components that might make a good
proposal. 

To that end, I suggest you look at Google's guidelines for what the
proposal should include:
http://www.google-melange.com/document/show/gsoc_program/google/gsoc2013/help_page#5._What_should_a_student_proposal_look).
 

Also, I think it a good idea to identify a few aims and specific
features that you intend to work on through the summer. Completing and
polishing all of the non-linear enhancements is quite a bit of work, and
may require more than the few months available. I know that all of the
LyX developers are hopeful that the summer of code students will become
long-term contributors. I certainly am.

# Project Overview

If you haven't already done so, I would strongly recommend that you read
through the non-linear writing essay at the link below:

http://blog.oak-tree.us/index.php/2009/03/04/perfect-tool

It provides a thorough overview of what I was hoping to accomplish with
the non-linear enhancements (which I will refer to as LyX-Outline from
here on out). From here, I will assume that you've read that original
essay and are familiar with the general aims of the project.

Since that original post, I've done quite a bit of work to move that
vision forward. This includes an initial prototype (written in Python):

http://blog.oak-tree.us/index.php/2009/05/13/lyx-outline

# Current Status #

An initial implementation of the core C++ classes needed to integrate
the enhancements into LyX proper. Here is what has been completed:

1. There is a candidate implementation of an *integrated* corkboard and
outliner pane that are connected to a single instance of a
QStandardItemModel
(http://qt-project.org/doc/qt-4.8/qstandarditemmodel.html).

2. To help facilitate communication between the view classes (corkboard
and outliner), I've written a DataManager class that can be used to
communicate with the LyX backend, which uses a message/action system to
process events.

All of these components work as expected (though there are some
stability bugs which need to be addressed), and you can try them by
building the program from the LyX-Outline branch on Launchpad:
https://launchpad.net/lyx-outline

Instructions on how to do this can be found at:
http://blog.oak-tree.us/index.php/2010/06/25/lyx-outline02-1

This means that the *core* vision of what I described above is mostly
complete. There are still a pretty large number of unfinished things,
which are detailed here:
http://blog.oak-tree.us/index.php/2010/07/19/lyx-outline02-3

But as a whole, they are pretty minor. Which leads me to a question of
my own. I'm not sure I understand what you are asking in the section of
your email below?

> 2. About the "combining outliner and corkboard idea": I wasn't sure 
> what did that mean when I saw in the project description that the student 
> is expected to "integrate" the two methods. I'm glad that we are thinking 
> of the same thing and it is a very exciting idea.
> 
In most ways, the outliner and corkboard are already integrated. They
use a common model and get their data from the underlying document
structure. What do you mean when you talk about "integration"?

With that said, it would be nice if they were used a slightly better
method to communicate with LyX's core. Right now, the model where they
draw their data from is regenerated each time there is a major update to
the document (such as the enter key or backspace key being pressed).
This is done by scanning the in-memory representation of the doc and
picking out certain portions (called insets). For larger documents, this
is pretty inefficient and can lead to noticeable lags.

A much better system would be to use signals and slots:
http://qt-project.org/doc/qt-4.8/signalsandslots.html

This would allow for various items in the model to subscribe to objects
in the document and be notified of changes. At the time I did the
original implementation of LyX-Outline, I decided not to take this
route, though, because signals/slots were not allowed in the core of
LyX. That has since changed:
http://www.mail-archive.com/lyx-devel@lists.lyx.org/msg172533.html

Modifying the LyX model so that a few insets, such as the text inset and
note inset (which form the foundation of the document model used in the
corkboard/outliner), would be a very good start to a GSOC project. It is
nicely bounded with specific aims, and would provide a springboard to
more ambitious goals, such as the draft interface you describe below.
> 
> 3. About that "draft" interface to allow users to drag and rearrange
> elements of the text, I haven't seen any application similar to my
> idea. Maybe the closest idea to dragging blocks of sentences is how
> you drag files in the list (either on a Mac or a PC) and rearrange
> them, and in terms of dragging single words or phrases, think of how
> you drag bookmarks on a bookmark bar in Safari. I personally would be
> totally impressed if my text editor could do that.

I think this sounds like a very nice enhancement to LyX. As of right
now, the outline branch has a limited version of this feature, based
upon defined sections (similar to the way the outline view in Word
works). Each section may then have a note associated with it, and it's
parent text. The notes, title, and text are kept in a model, and can be
manipulated: re-ordered through drag and drop, indented/unindented, etc.

If I understand your thinking correctly, you would like to extend this
behavior to work on arbitrary snippets of text? Is that correct?

There is a writing program called Scrivener which allows for a type of
this where text snippets do not need to be tied to specific sections.
See the link below for an overview of how it works:
http://literatureandlatte.com/scrivener.php

Is this similar to what you were thinking? If not, could you expand upon
your original idea? How did you imagine splitting the writing into
different chunks? What meta-data did you imagine being associated with
each component?

How do you imagine this information being rendered on screen? Would it
follow similar metaphors as used by Scrivener, or a more abstract series
of metaphors used by another writing program (such as Information
Architects writer: http://www.iawriter.com/ipad/).

# Next Steps #

I understand that I've covered quite a bit of ground in this email and
provided a deluge of links. Here are a few next steps that I think will
get you closer to a project proposal.

1. You need to select a one or two *well defined* aspects of the
non-linear writing enhancements that sounds of interest. One example
might be to move the LyX core inset classes to QObject and adjust the
TOC model to work on the basis of signals and slots.

or, you might adjust the corkboard view to use QGraphicsScene:
http://qt-project.org/doc/qt-4.8/qgraphicsscene.html

The QGraphicsScene classes provide for a more performant base than
QWidget (which we use now), and would allow for more flexible notecard
views. Indeed, it might even be possible to create specialized views for
more than just sections of text; figures, for example, might have one
type of notecard (including images); and references, a third.

Or you might decide to pursue something else entirely, such as what your
draft view would require.

2. Once you settle on one or two major goals, we can start to talk about
the best way to implement them, pick milestones, and discuss a timeline
for deliverables. The more concrete you can be about the above, the
better chance your proposal will have of being accepted. (See
http://www.di.ens.fr/~baghdadi/TXT_blog/5_advices_to_get_your_proposal_accepted.lyx.html
 which has several pieces of advice for writing a strong proposal.)

# Conclusion #

As I said before, I'm looking forward to working with you and sincerely
hope that your project will be approved. Discussing the non-linear
enhancements has gotten me excited to pick up on several of my own LyX
projects and to produce a killer writing environment.

Cheers,

Rob Oakes


Reply via email to