Exactly. To customize the label that appears in the tree, you need to
specify a format block that will take each node as an input and should
produce a string or text as an output.

Cheers,
Doru


On Tue, Aug 12, 2014 at 9:45 PM, Offray Vladimir Luna Cárdenas <
off...@riseup.net> wrote:

> Hi again,
>
> Well, after adding the code to the proper object I don't get any error
> stacks. So far, so good. I'll keep you posted.
>
> Thanks again,
>
> Offray
>
>
> On 08/12/2014 02:08 PM, Offray Vladimir Luna Cárdenas wrote:
>
>> Hi Peter and community,
>>
>> First thanks Perter for your quick answer and sorry for my late one.
>> Your advice worked like a charm and now I can see node information
>> (headers and body in any panel I want). The only thing is that I get a
>> lot of error message in a stack. They're referred to:
>>
>> - NonBooleanReceiver: proceed for truth
>> - MessageNotUnderstood: AnObsoleteGLMPagerCircleButtonMorph >> isFocused
>> (I got this one twice).
>>
>> I don't know how to debug the stacks and, at the beginning I was
>> thinking that they're related with how to deal with empty values while
>> traversing the tree, so I put some ifTrue, ifFalse messages to deal with
>> them. Still I get the same errors. The main difference with the
>> structure of Peter's code is that I'm not using "display:" keyword, but
>> I don't see it used either on the treeWithChildrenByLevel example.
>>
>> Anyway I will replace my current GUI implementation with this code that
>> works better and start to deal with other parts of the project and keep
>> the community posted (and myself reading).
>>
>> Here is my code:
>>
>> (by the way, Tabs look nice on Pharo/Moose, but they're look terrible on
>> email. There is any way to get them replace by spaces?)
>>
>> =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
>> | browser mainTree |
>>
>> mainTree := UbakyeNode new.
>> mainTree becomeDefaultTree.
>>
>> browser := GLMTabulator new.
>> browser
>>      column: #tree;
>>      column: [ :c |
>>                  c
>>                      row: #body;
>>                      row: #plugins ].
>> (browser transmit)
>>      to: #tree;
>>      andShow: [ :a |
>>                  (a tree)
>>                      title: mainTree header;
>>                      children: [ :eachNode |
>>                          (eachNode children) isNil
>>                              ifTrue: [ #() ]
>>                              ifFalse:[ eachNode children ] ];
>>                      format:[:eachNode |
>>                          (eachNode header) isNil
>>                              ifTrue: [ '' ]
>>                              ifFalse: [ eachNode header ] ].
>>                      "Children must return a collection" ].
>> (browser transmit)
>>      to: #body;
>>      from: #tree;
>>      andShow: [ :a |
>>                  (a text)
>>                      title: 'Cuerpo | Body ';
>>                      format:[:eachNode |
>>                          (eachNode body) isNil
>>                               ifTrue: [ '' ]
>>                              ifFalse: [ eachNode body ] ]
>>
>>                  ].
>> (browser transmit)
>>      to: #plugins;
>>      andShow: [ :a | a text title: 'Plugins | Extensiones' ].
>>
>> browser openOn: mainTree children.
>> =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
>>
>> On 08/09/2014 04:05 AM, PBKResearch wrote:
>>
>>> Hi Offray
>>>
>>> Well, none of the experts has come forward to help, so maybe I can
>>> comment as almost a complete beginner. I think you need two additional
>>> bits of specification in your example to get the output you want:
>>>
>>> a. To show the node titles in the #tree pane, you need to add a
>>> format: clause, which is a block taking the node as argument and
>>> returning the text to be output.
>>>
>>> b. To show the body of the selected tree node in the #body pane, you
>>> need a display: clause, which is a similar block generating the body
>>> details that you want.
>>>
>>> To give you a specific example, here is some code I have used. I am
>>> using a GlamorousBrowser to examine the tree representation of an HTML
>>> page generated by Todd Blanchard's superb HTMLCSS parser. The browser
>>> I produce is similar to yours, but without the #plugins pane.
>>>
>>> domBrowser := GLMTabulator new.
>>> domBrowser
>>>        column:  #details;
>>>     column: #nodeDetails.
>>> domBrowser transmit to: #details; andShow: [ :a |
>>>     a tree
>>>        display: [ :model | model nodesSelect: [ :each | each tag =
>>> 'html'] ];
>>>        children: [ :node | node children ];
>>>        format: [ :node ||nid| node tag,' ', ((nid := node id) isNil
>>> ifTrue:[''] ifFalse:['id=',nid,' '])] ].
>>> domBrowser transmit from: #details; to: #nodeDetails;
>>>          andShow: [ :each| each text display: [:node| node
>>> innerContents ]].
>>> domBrowser title: 'Browse HTML'.
>>>
>>> I hope this makes it clear; if not, ask again.
>>>
>>> Best wishes
>>>
>>> Peter Kenny
>>>
>>> -----Original Message-----
>>> From: Pharo-users [mailto:pharo-users-boun...@lists.pharo.org] On
>>> Behalf Of Offray Vladimir Luna Cárdenas
>>> Sent: 09 August 2014 05:08
>>> To: pharo-users@lists.pharo.org
>>> Subject: [Pharo-users] Rephrasing my question on Stackoverflow (Re:
>>> [Moose-dev] Re: Tree/Outliners of playgrounds, markdown inside
>>> comments and some quick medium size dreams for Pharo/Smalltalk)
>>>
>>> Hi again,
>>>
>>> I'm testing my luck in Stackoverflow to see if I can get more eyes and
>>> keep the conversation going:
>>>
>>> http://stackoverflow.com/questions/25215103/building-a-
>>> tree-outliner-like-graphical-interface-in-pharo-smalltalk-using-moose
>>>
>>>
>>> This community is very responsive but I feel I'm not understanding
>>> quickly/properly enough the main logic of tree-like browsers on Moose.
>>> So, any extra help is welcomed.
>>>
>>> Cheers,
>>>
>>> Offray
>>>
>>>
>>> On 08/07/2014 03:28 PM, Offray Vladimir Luna Cárdenas wrote:
>>>
>>>> Hi Doru and Community :-),
>>>>
>>>> In the screenshot at [1] you can see my explorations. I took the code
>>>> from treeWithChildrenByeLevel in the GLMBasicExamples and modified it
>>>> until I got this:
>>>>
>>>> [1] http://www.enlightenment.org/ss/e-53e3dee6777744.68598023.jpg
>>>>
>>>> So I have now a browser which shows a tree made of UbakyeNodes (a tree
>>>> like data structure I defined), but I would like not to show the
>>>> Ubakye Nodes, but the titles of each node (headers) and the contents
>>>> (bodies) of them when selected. With your help I have understood that
>>>> I need to pass the collection of all children (not just the headers of
>>>> them), but I don't know who to sellect something particular in that
>>>> collection to be shown on the browser, like headers of nodes in the
>>>> #tree panel or bodies in the #body panel.
>>>>
>>>> I would like to change also the size of each panel to be more like the
>>>> shown in the screenshot, instead of the default one and be relative to
>>>> window size. Is this possible?
>>>>
>>>> Thanks,
>>>>
>>>> Offray
>>>>
>>>> Below is the code, for easiness of reading:
>>>>
>>>> =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
>>>> "
>>>> Another exploration of Outliners provided by Glamorous Toolkit and
>>>> browsers. This code was obtained by running 'GLMBasicExamples open'
>>>> and then browsing until 'treeWithChildrenByLevel'. Some code was
>>>> modified to open explicitely the browser on the world and starting to
>>>> hack on it.
>>>> "
>>>>
>>>>       | browser mainTree |
>>>>
>>>>       mainTree := UbakyeNode new.
>>>>       mainTree becomeDefaultTree.
>>>>
>>>>       browser := GLMTabulator new.
>>>>       browser
>>>>           column: #tree;
>>>>           column: [ :c |
>>>>                       c
>>>>                           row: #body;
>>>>                           row: #plugins ].
>>>>       (browser transmit)
>>>>           to: #tree;
>>>>           andShow: [ :a |
>>>>                       (a tree)
>>>>                           title: mainTree header;
>>>>                           children: [ :eachNode |
>>>>                                       eachNode children. ]    "Children
>>>> must return a collection" ].
>>>>       (browser transmit)
>>>>           to: #body;
>>>>           from: #tree;
>>>>           andShow: [ :a | a text title: 'Cuerpo | Body ' ].
>>>>       (browser transmit)
>>>>           to: #plugins;
>>>>           from: #tree port: #selectionPath;
>>>>           andShow: [ :a | a text title: 'Plugins | Extensiones' ].
>>>>
>>>>       browser openOn: mainTree children.
>>>> =-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-
>>>>
>>>>
>>>> On 08/05/2014 12:19 AM, Tudor Girba wrote:
>>>>
>>>>> Hi,
>>>>>
>>>>> You probably need this:
>>>>>
>>>>> explorer transmit to: #tree; andShow: [:a |
>>>>>                    a tree
>>>>>                            display: headers;
>>>>> *children: [:eachNode | eachNode
>>>>> theMessageYouUseToGoToTheChildrenOfANode ]*].
>>>>>
>>>>> A tree is a recursive structure, and to describe it you need:
>>>>> - a way to construct the root elements. This is the result of
>>>>> applying
>>>>> display:
>>>>> to the input object. So, display: either takes a collection or a
>>>>> block that will return a collection when executed.
>>>>> - a way to define the children for each node. This is the result of
>>>>> applying
>>>>> children:
>>>>>
>>>>> You should also take a look at the examples from:
>>>>> GLMBasicExamples open
>>>>>
>>>>> Does this help now?
>>>>>
>>>>> Cheers,
>>>>> Doru
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>> On Sun, Jul 27, 2014 at 4:59 PM, Offray Vladimir Luna Cárdenas
>>>>> <off...@riseup.net <mailto:off...@riseup.net>> wrote:
>>>>>
>>>>>       Hi,
>>>>>
>>>>>       Answering to myself: I have solved the code that selects the
>>>>> headers of the
>>>>>       main tree. The key is to create a new collection containing only
>>>>> node names.
>>>>>       Here is the code:
>>>>>
>>>>>       "*************************"
>>>>>       | mainTree node1 node2 explorer headers  |
>>>>>
>>>>>       mainTree := UbakyeNode
>>>>>                header: 'Arbol raíz'
>>>>>                body: ''.
>>>>>
>>>>>       node1 := UbakyeNode
>>>>>                header: 'Nodo 1'
>>>>>                body:  'Texto 1'.
>>>>>
>>>>>       node2 := UbakyeNode
>>>>>                header: 'Nodo 2'
>>>>>                body:  'Texto 2'.
>>>>>
>>>>>       mainTree
>>>>>                addNode: node1;
>>>>>                addNode: node2.
>>>>>
>>>>>
>>>>>       explorer := GLMTabulator new
>>>>>                        title: (mainTree header).
>>>>>       explorer column: #tree;
>>>>>                 column: #body.
>>>>>
>>>>>       headers := (mainTree children)
>>>>>                collect: [:node |  node header].
>>>>>
>>>>>
>>>>>       explorer transmit to: #tree; andShow: [:a |
>>>>>                        a tree
>>>>>                                display: headers].
>>>>>
>>>>>       explorer openOn: mainTree.
>>>>>
>>>>>       "*************************"
>>>>>
>>>>>       Now I need to make the children sellectable, and that all the
>>>>> contents of
>>>>>       the tree can be updated with a shortcut.
>>>>>
>>>>>       I will keep you posted.
>>>>>
>>>>>       Cheers,
>>>>>
>>>>>       Offray
>>>>>
>>>>>
>>>>>       On 07/26/2014 09:01 PM, Offray Vladimir Luna Cárdenas wrote:
>>>>>
>>>>>           Hi again,
>>>>>
>>>>>           I will be using this thread to update my advances and
>>>>> questions about
>>>>>           how to build an outliner in Pharo Smalltalk. If there is a
>>>>> better method
>>>>>           like starting a new thread for particular questions, or a
>>>>> less narrative
>>>>>           style, please let me know.
>>>>>
>>>>>           The idea is to use the tools provided by Moose to build a
>>>>> quick outliner
>>>>>           that can be extended to suit my needs on academical writing.
>>>>> This is
>>>>>           kind of a strange approach in the sense that I'm not
>>>>> following the
>>>>>           tutorials with a predefined problems (make a game and so)
>>>>> but trying to
>>>>>           start with a real (in the sense of closer) problem (making
>>>>> an
>>>>> outliner)
>>>>>           and to see which knowledge I need to solve this necessity.
>>>>> In that sense
>>>>>           is more like the Freire's alphabetization of adults in
>>>>> Brazil.
>>>>>
>>>>>           So, the things I have done so far was to search for a good
>>>>> model to
>>>>>           start with. Something already done that can be used as
>>>>> scaffolding for
>>>>>           my outliner. The Help System seems like a good start for an
>>>>> outliner (in
>>>>>           fact it is already one), so I have taken the Help-Core
>>>>> system and start
>>>>>           to use it as a base for my project.
>>>>>
>>>>>           After that I have used the Moose browsers to build a simple
>>>>> interface,
>>>>>           as seen here:
>>>>>
>>>>>
>>>>> http://mutabit.com/offray/__static/blog/output/galleries/__objetos/ub
>>>>> akye-browser.jpg
>>>>>
>>>>>
>>>>> <http://mutabit.com/offray/static/blog/output/galleries/objetos/ubaky
>>>>> e-browser.jpg>
>>>>>
>>>>>
>>>>>
>>>>>           The part I want to deal with is this:
>>>>>
>>>>>           ===============
>>>>>
>>>>>           explorer := GLMTabulator new
>>>>>                             title: (mainTree header).
>>>>>           explorer column: #tree;
>>>>>                         column: #body.
>>>>>
>>>>>           explorer transmit to: #tree; andShow: [:a |
>>>>>                     a tree
>>>>>                         display: mainTree children ].
>>>>>
>>>>>           explorer openOn: mainTree.
>>>>>
>>>>>           ===============
>>>>>
>>>>>           So, instead of "display: mainTree children" I need something
>>>>> that takes
>>>>>           the get names (headers) of the two nodes and the contents in
>>>>> the right
>>>>>           panel. For that I think that I need to learn some iterators.
>>>>> I have
>>>>>           already a "header" method for the nodes. Any clue would be
>>>>> appreciated
>>>>>           and I will keep you posted on my advances.
>>>>>
>>>>>           Cheers,
>>>>>
>>>>>           Offray
>>>>>
>>>>>
>>>>>           On 07/21/2014 12:58 PM, Offray Vladimir Luna Cárdenas wrote:
>>>>>
>>>>>               Hi Damien,
>>>>>
>>>>>               Thanks for your answer. Comments below.
>>>>>
>>>>>               On 07/21/2014 11:09 AM, Damien Cassou wrote:
>>>>>
>>>>>                   On Sat, Jul 19, 2014 at 2:47 AM, Offray Vladimir
>>>>> Luna Cárdenas
>>>>>                   <off...@riseup.net <mailto:off...@riseup.net>>
>>>>> wrote:
>>>>>
>>>>>                       The first idea that comes to mind is using STON
>>>>> for storage
>>>>>                       nodes and
>>>>>                       tree
>>>>>                       information, so I can interchange it with the
>>>>> flatland files
>>>>>                       world
>>>>>                       and keep
>>>>>                       it readable. Sounds that reasonable?
>>>>>
>>>>>
>>>>>
>>>>>                   without more information, it is hard to stay. Try
>>>>> with STON and
>>>>>                   change
>>>>>                   if that does not work :-). We have XML and JSON
>>>>> generators as well.
>>>>>
>>>>>
>>>>>
>>>>>               This is a kind of raw preview of I'm talking about:
>>>>>
>>>>>
>>>>> http://www.enlightenment.org/__ss/e-53cd4f36f021e9.68569046.__jpg
>>>>>
>>>>> <http://www.enlightenment.org/ss/e-53cd4f36f021e9.68569046.jpg>
>>>>>
>>>>>               Of course in this case, it is just a Help browser with a
>>>>> Playground
>>>>>               window over it, but I would like to have something like
>>>>> Playgrounds
>>>>>               inside the help browser. I was trying to build a custom
>>>>> browser with
>>>>>               Glamour, but seems that Help Browser already has the
>>>>> machinery I'm
>>>>>               looking for.
>>>>>
>>>>>               So my first question is how to use the Help Browser
>>>>> class as a template
>>>>>               for my outliner class? And can I put a Playground where
>>>>> the plain text
>>>>>               is located right now?
>>>>>
>>>>>
>>>>>                       The second thing I would like to do is to add
>>>>> pandoc's
>>>>>                       markdown inside
>>>>>                       comments, but I don't like the syntax of
>>>>> comments in
>>>>>                       Smalltalk because
>>>>>                       single quotes are fairly easy to find in light
>>>>> markup
>>>>>                       language like
>>>>>                       markdown. Is difficult to change it to create
>>>>> something more
>>>>>                       like
>>>>>                       python
>>>>>                       (with """) or Lua (with -[]- )?
>>>>>
>>>>>
>>>>>
>>>>>                   There is only one syntax for comments in Pharo.
>>>>> Instead of Markdown,
>>>>>                   you might want to have a look at Pillar which is
>>>>> implemented in
>>>>>                   Pharo
>>>>>                   and can generate Markdown (and html, and pdf) :
>>>>>
>>>>> https://github.com/pillar-__markup/pillar-documentation/
>>>>>
>>>>> <https://github.com/pillar-markup/pillar-documentation/>
>>>>>
>>>>>
>>>>>
>>>>>               I have seen Pillar. Seems really interesting, but
>>>>> Pandocs markdown
>>>>>               support academic citation in several formats and I have
>>>>> already long
>>>>>               docs wrote on that format integrated in my workflow from
>>>>> Zotero and even
>>>>>               there is a growing community working on Scholarly
>>>>> Markdown[1][2] so I
>>>>>               would like to stick with it as much as I can for my own
>>>>> writing.
>>>>>               That being said. I would like also a better integration
>>>>> between
>>>>>               Smalltalk outliners and all the academic publication
>>>>> work flow,
>>>>>               including working better with pandoc as a external
>>>>> library.
>>>>>
>>>>>               [1] https://github.com/scholmd/__scholmd/wiki
>>>>>               <https://github.com/scholmd/scholmd/wiki>
>>>>>               [2]
>>>>>
>>>>> http://blog.martinfenner.org/__2013/06/29/metadata-in-__scholarly-mar
>>>>> kdown/
>>>>>
>>>>>
>>>>> <http://blog.martinfenner.org/2013/06/29/metadata-in-
>>>>> scholarly-markdown/>
>>>>>
>>>>>               [3]
>>>>>
>>>>> http://programminghistorian.__org/lessons/sustainable-__authorship-in
>>>>> -plain-text-__using-pandoc-and-markdown
>>>>>
>>>>>
>>>>> <http://programminghistorian.org/lessons/sustainable-authorship-in-pl
>>>>> ain-text-using-pandoc-and-markdown>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>               Thanks again, this conversation with people in the
>>>>> community is very
>>>>>               valuable to me,
>>>>>
>>>>>               Offray
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>       _________________________________________________
>>>>>       Moose-dev mailing list
>>>>>       moose-...@iam.unibe.ch <mailto:moose-...@iam.unibe.ch>
>>>>>       https://www.iam.unibe.ch/__mailman/listinfo/moose-dev
>>>>>       <https://www.iam.unibe.ch/mailman/listinfo/moose-dev>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>> --
>>>>> www.tudorgirba.com <http://www.tudorgirba.com>
>>>>>
>>>>> "Every thing has its own flow"
>>>>>
>>>>>
>>>>
>>>>
>>>>
>>>
>>>
>>>
>>>
>>
>
>


-- 
www.tudorgirba.com

"Every thing has its own flow"

Reply via email to