xref: /aoo42x/main/toolkit/workben/layout/editor.cxx (revision 6d53c851)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 #include "editor.hxx"
25 
26 #undef NDEBUG
27 
28 /*
29 #include <stdio.h>
30 #include <string.h>
31 */
32 
33 #include <cassert>
34 #include <cstdio>
35 #include <cstring>
36 #include <list>
37 #include <vector>
38 
39 #include <com/sun/star/awt/WindowAttribute.hpp>
40 #include <com/sun/star/awt/XLayoutConstrains.hpp>
41 #include <com/sun/star/awt/XLayoutContainer.hpp>
42 #include <com/sun/star/awt/XToolkit.hpp>
43 #include <com/sun/star/awt/XVclWindowPeer.hpp>
44 #include <com/sun/star/awt/XWindow.hpp>
45 #include <com/sun/star/awt/XWindowPeer.hpp>
46 #include <rtl/strbuf.hxx>
47 #include <rtl/ustrbuf.hxx>
48 #include <toolkit/helper/property.hxx>
49 #include <vcl/lstbox.h>
50 
51 using namespace layout::css;
52 
53 using rtl::OUString;
54 
55 // FIXME:
56 //#define FILEDLG
57 
58 #include <layout/core/helper.hxx>
59 #include <layout/core/root.hxx>
60 #include <layout/core/helper.hxx>
61 
62 // TODO: automatically generated
63 struct WidgetSpec {
64     const char *pLabel, *pName, *pIconName;
65     bool bIsContainer; };
66 static const WidgetSpec WIDGETS_SPECS[] = {
67     { "Label",         "fixedtext"   , "sc_label.png",        false },
68     { "Button",        "pushbutton"  , "sc_pushbutton.png",   false },
69     { "Radio Button",  "radiobutton" , "sc_radiobutton.png",  false },
70     { "Check Box",     "checkbox"    , "sc_checkbox.png",     false },
71     { "Line Edit",     "edit"        , "sc_edit.png",         false },
72     { "Numeric Field", "numericfield", "sc_numericfield.png", false },
73     { "List Box                  ", "listbox"     , NULL,                  false },
74     // containers
75     { "Hor Box",       "hbox"        , NULL,                  true  },
76     { "Ver Box",       "vbox"        , NULL,                  true  },
77     { "Table",         "table"       , NULL,                  true  },
78     { "Alignment",     "align"       , NULL,                  true  },
79     { "Tab Control",   "tabcontrol"  , NULL,                  true  },
80     { "Hor Splitter",  "hsplitter"   , NULL,                  true  },
81     { "Ver Splitter",  "vsplitter"   , NULL,                  true  },
82     { "Scroller",      "scroller"    , NULL,                  true  },
83 };
84 const int WIDGETS_SPECS_LEN = sizeof (WIDGETS_SPECS) / sizeof (WidgetSpec);
85 
86 using namespace layout;
87 using namespace layoutimpl;
88 namespace css = ::com::sun::star;
89 
anyToString(uno::Any value)90 static rtl::OUString anyToString (uno::Any value)
91 {
92     try
93     {
94         switch (value.getValueTypeClass()) {
95             case uno::TypeClass_STRING:
96                 return value.get<rtl::OUString>();
97             case uno::TypeClass_CONSTANT:
98                 return rtl::OUString::valueOf (value.get<sal_Int32>());
99             case uno::TypeClass_LONG:
100                 return rtl::OUString::valueOf (value.get<sal_Int64>());
101             case uno::TypeClass_SHORT:
102                 // FIXME: seems broken
103                 return rtl::OUString::valueOf ((sal_Int32) value.get<short>());
104 
105             case uno::TypeClass_FLOAT:
106                 return rtl::OUString::valueOf (value.get<float>());
107             case uno::TypeClass_DOUBLE:
108                 return rtl::OUString::valueOf (value.get<double>());
109 
110             case uno::TypeClass_BOOLEAN:
111             {
112                 bool val = value.get<sal_Bool>();
113                 return rtl::OUString( val ? "1" : "0", 1, RTL_TEXTENCODING_ASCII_US );
114 /*                if ( val )
115                   return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "true" ) );
116                   else
117                   return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "false" ) );*/
118             }
119             default:
120                 break;
121         }
122     }
123     catch(...) {}
124     return rtl::OUString();
125 }
126 
anyToNatural(uno::Any value)127 static inline long anyToNatural (uno::Any value)
128 { return sal::static_int_cast<long>(anyToString( value ).toInt64()); }
anyToDecimal(uno::Any value)129 static inline double anyToDecimal (uno::Any value)
130 { return anyToString( value ).toDouble(); }
131 
132 /* XLayoutContainer/XLayoutConstrains are a bit of a hasle to work with.
133    Let's wrap them. */
134 class Widget : public layoutimpl::LayoutWidget
135 {
136     friend class EditorRoot;
137 
138     Widget *mpParent;
139     std::vector< Widget *> maChildren;
140     bool mbForeign;
141 
142     rtl::OUString mrId;
143     rtl::OUString mrLabel, mrUnoName;
144 
145 // TODO: store original properties. And some property handling methods.
146     long mnOriAttrbs;
147     layoutimpl::PropList maOriProps, maOriChildProps;
148 
149 public:
150 
151     // to be used to wrap the root
Widget(uno::Reference<awt::XLayoutConstrains> xImport,const char * label)152     Widget( uno::Reference< awt::XLayoutConstrains > xImport, const char *label )
153         : mpParent( 0 ), mbForeign( true )
154     {
155         mxWidget = xImport;
156         mxContainer = uno::Reference< awt::XLayoutContainer >( mxWidget, uno::UNO_QUERY );
157 
158         mrLabel = rtl::OUString( label, strlen( label ), RTL_TEXTENCODING_UTF8  );
159 
160 #if 0  /* obsolete */
161         // FIXME: this code is meant to import a XML file. Just use the importer,
162         // then pass the root widget. But information like the ID string is lost.
163         // So, this needs to be more closely tight to the importer.
164         uno::Sequence< uno::Reference< awt::XLayoutConstrains > > aChildren;
165         for ( int i = 0; i < aChildren.getLength(); i++ )
166         {
167             Widget *pChild = new Widget( aChildren[ i ], "---" );
168             maChildren.push_back( pChild );
169             pChild->mpParent = this;
170         }
171 #endif
172     }
173 
Widget(rtl::OUString id,uno::Reference<awt::XToolkit> xToolkit,uno::Reference<awt::XLayoutContainer> xParent,rtl::OUString unoName,long nAttrbs)174     Widget( rtl::OUString id, uno::Reference< awt::XToolkit > xToolkit,
175             uno::Reference< awt::XLayoutContainer > xParent,
176             rtl::OUString unoName, long nAttrbs )
177         : mpParent( 0 ), mbForeign( false ), mrId( id ),
178           mnOriAttrbs( nAttrbs )
179     {
180         while ( xParent.is() && !uno::Reference< awt::XWindow >( xParent, uno::UNO_QUERY ).is() )
181         {
182             uno::Reference< awt::XLayoutContainer > xContainer( xParent, uno::UNO_QUERY );
183             OSL_ASSERT( xContainer.is() );
184             xParent = uno::Reference< awt::XLayoutContainer >( xContainer->getParent(), uno::UNO_QUERY );
185         }
186 
187         mxWidget = WidgetFactory::createWidget( xToolkit, xParent, unoName, nAttrbs );
188         OSL_ASSERT( mxWidget.is() );
189         mxContainer = uno::Reference< awt::XLayoutContainer >( mxWidget, uno::UNO_QUERY );
190 
191         mrLabel = mrUnoName = unoName;
192         // try to get a nicer label for the widget
193         for ( int i = 0; i < WIDGETS_SPECS_LEN; i++ )
194             if ( unoName.equalsAscii( WIDGETS_SPECS[ i ].pName ) )
195             {
196                 const char *label = WIDGETS_SPECS[ i ].pLabel;
197                 mrLabel = rtl::OUString( label, strlen( label ), RTL_TEXTENCODING_UTF8  );
198                 break;
199             }
200 
201         // set default Text property
202         // TODO: disable editing of text fields, check boxes selected, etc...
203 #if 0
204         uno::Reference< awt::XVclWindowPeer> xVclPeer( mxWidget, uno::UNO_QUERY )
205             if ( xVclPeer.is() ) // XVclWindowPeer ignores missing / incorrect properties
206 
207 //FIXME: it looks odd on widgets like NumericField seeing text which is deleted
208 // when you interact with it... We can avoid it for those widgets, by doing a getProp
209 // of "Text" and check if it is empty or not.
210 
211                 xVclPeer->setProperty( rtl::OUString::createFromAscii( "Text" ),
212                                        uno::makeAny( rtl::OUString::createFromAscii( "new widget" ) ) );
213 #endif
214 
215         // store original properties
216         {
217             PropertyIterator it( this, WINDOW_PROPERTY );
218             while ( it.hasNext() )
219             {
220                 beans::Property prop = it.next();
221                 rtl::OUString name( prop.Name );
222                 rtl::OUString value( getProperty( name, WINDOW_PROPERTY ) );
223 #if DEBUG_PRINT
224                 fprintf(stderr, "original property: %s = %s\n", OUSTRING_CSTR(name), OUSTRING_CSTR(value));
225 #endif
226                 std::pair< rtl::OUString, rtl::OUString > pair( name, value );
227                 maOriProps.push_back( pair );
228             }
229         }
230 
231     }
232 
~Widget()233     ~Widget()
234     {
235         for ( std::vector< Widget *>::const_iterator it = maChildren.begin();
236              it != maChildren.end(); it++ )
237             delete *it;
238         if ( !mbForeign )
239         {
240             uno::Reference< lang::XComponent > xComp( mxWidget, uno::UNO_QUERY );
241             if ( xComp.is() )
242                 // some widgets, like our containers, don't implement this interface...
243                 xComp->dispose();
244         }
245     }
246 
impl()247     uno::Reference< awt::XLayoutConstrains > impl()
248     {
249         return mxWidget;
250     }
251 
252     // LayoutWidget
addChild(LayoutWidget * pChild)253     virtual bool addChild( LayoutWidget *pChild )
254     {
255         return addChild( static_cast< Widget * >( pChild ) );
256     }
257 
setProperties(const PropList & rProps)258     virtual void setProperties( const PropList &rProps )
259     {
260 //        maOriProps = rProps;
261         LayoutWidget::setProperties( rProps );
262     }
263 
setChildProperties(LayoutWidget * pChild,const PropList & rProps)264     virtual void setChildProperties( LayoutWidget *pChild, const PropList &rProps )
265     {
266         maOriChildProps = rProps;
267         LayoutWidget::setChildProperties( pChild, rProps );
268     }
269 
270     // tree travel
up()271     Widget *up()
272     {
273         return mpParent;
274     }
275 
down()276     Widget *down()
277     {
278         if ( maChildren.empty() )
279             return NULL;
280         return maChildren.front();
281     }
282 
next()283     Widget *next()
284     {
285         if ( mpParent )
286         {
287             int pos = mpParent->getChildPos( this );
288             return mpParent->getChild( pos+1 );
289         }
290         return NULL;
291     }
292 
prev()293     Widget *prev()
294     {
295         if ( mpParent )
296         {
297             int pos = mpParent->getChildPos( this );
298             return mpParent->getChild( pos-1 );
299         }
300         return NULL;
301     }
302 
303     // handle
addChild(Widget * pChild,int pos=0xffff)304     bool addChild( Widget *pChild, int pos = 0xffff )
305     {
306         if ( !mxContainer.is() )
307             return false;
308 
309         uno::Sequence< uno::Reference < awt::XLayoutConstrains > > aChildren;
310         aChildren = mxContainer->getChildren();
311         int nChildrenLen = aChildren.getLength();
312 
313         // ugly, but let's check if the container is next to full...
314         try {
315             mxContainer->addChild( pChild->mxWidget );
316         }
317         catch( awt::MaxChildrenException ex ) {
318             return false;
319         }
320 
321         if ( pos < nChildrenLen )
322         {  // if its on the middle, we need to make space for it
323             mxContainer->removeChild( pChild->mxWidget );
324             for ( int i = pos; i < nChildrenLen; i++ )
325                 mxContainer->removeChild( aChildren[ i ] );
326             mxContainer->addChild( pChild->mxWidget );
327             for ( int i = pos; i < nChildrenLen; i++ )
328                 mxContainer->addChild( aChildren[ i ] );
329             maChildren.insert( maChildren.begin()+pos, pChild );
330         }
331         else
332             maChildren.push_back( pChild );
333 
334         OSL_ASSERT( pChild->mpParent == NULL );
335         pChild->mpParent = this;
336 
337         // store container props
338         {
339             pChild->maOriChildProps.clear();
340             PropertyIterator it( pChild, CONTAINER_PROPERTY );
341             while ( it.hasNext() )
342             {
343                 beans::Property prop = it.next();
344                 rtl::OUString name( prop.Name );
345 		try {
346 			rtl::OUString value( pChild->getProperty( name, CONTAINER_PROPERTY ) );
347 			std::pair< rtl::OUString, rtl::OUString > pair( name, value );
348 			pChild->maOriChildProps.push_back( pair );
349 		} catch ( beans::UnknownPropertyException &rEx ) {
350 			fprintf (stderr, "ERROR: widget reports that it has a property it cannot return: '%s' this normally means that someone screwed up their PROPERTY_SET_INFO macro usage.\n",
351 				 rtl::OUStringToOString (rEx.Message, RTL_TEXTENCODING_UTF8).getStr());
352 		}
353             }
354         }
355 
356         return true;
357     }
358 
removeChild(Widget * pChild)359     bool removeChild( Widget *pChild )
360     {
361         if ( !mxContainer.is() || pChild->mpParent != this )
362             return false;
363 
364         mxContainer->removeChild( pChild->mxWidget );
365 
366         unsigned int pos = getChildPos( pChild );
367         if ( pos < maChildren.size() )
368             maChildren.erase( maChildren.begin()+pos );
369         pChild->mpParent = NULL;
370 
371         return true;
372     }
373 
swapWithChild(Widget * pChild)374     bool swapWithChild( Widget *pChild )
375     {
376         if ( !pChild->isContainer() )
377             return false;
378 
379         // remove all child's childrens, and try to add them here
380         removeChild( pChild );
381 
382         // keep a copy for failure
383         std::vector< Widget *> aChildren = maChildren;
384         std::vector< Widget *> aChildChildren = pChild->maChildren;
385 
386         for ( std::vector< Widget *>::const_iterator it = aChildChildren.begin();
387               it != aChildChildren.end(); it++ )
388             pChild->removeChild( *it );
389 
390         for ( std::vector< Widget *>::const_iterator it = aChildChildren.begin();
391               it != aChildChildren.end(); it++ )
392             if ( !addChild( *it ) )
393             {    // failure
394                 for ( std::vector< Widget *>::const_iterator jt = aChildChildren.begin();
395                       jt != it; jt++ )
396                     removeChild( *jt );
397                 for ( std::vector< Widget *>::const_iterator jt = aChildChildren.begin();
398                       jt != aChildChildren.end(); jt++ )
399                     pChild->addChild( *jt );
400                 return false;
401             }
402 
403         Widget *pParent = up();
404 
405         if ( pParent )
406         {
407             pParent->removeChild( this );
408             pParent->addChild( pChild );
409         }
410         pChild->addChild( this );
411         return true;
412     }
413 
getChildPos(Widget * pChild)414     unsigned int getChildPos( Widget *pChild )
415     {
416         int i = 0;
417         for ( std::vector< Widget *>::const_iterator it = maChildren.begin();
418               it != maChildren.end(); it++, i++ )
419             if ( *it == pChild )
420                 break;
421         return i;
422     }
423 
getChild(int pos)424     Widget *getChild( int pos )
425     {
426         if ( pos >= 0 && pos < (signed) maChildren.size() )
427             return *(maChildren.begin() + pos);
428         return NULL;
429     }
430 
isContainer()431     bool isContainer()
432     { return mxContainer.is(); }
getChildrenLen()433     unsigned int getChildrenLen()
434     { return maChildren.size(); }
435 
getLabel() const436     rtl::OUString getLabel() const
437     { return mrLabel; }
getUnoName() const438     rtl::OUString getUnoName() const
439     { return mrUnoName; }
440 
getDepth()441     int getDepth()
442     {
443         int depth = 0;
444         for ( Widget *pWidget = mpParent; pWidget; pWidget = pWidget->mpParent )
445             depth++;
446         return depth;
447     }
448 
449     enum PropertyKind {
450         WINDOW_PROPERTY, CONTAINER_PROPERTY, WINBITS_PROPERTY
451     };
452 
findProperty(const PropList & props,rtl::OUString propName)453     static rtl::OUString findProperty( const PropList &props, rtl::OUString propName )
454     {
455         for ( PropList::const_iterator it = props.begin(); it != props.end(); it++ )
456             if ( it->first.equalsIgnoreAsciiCase( propName ) )
457                 return it->second;
458 #if DEBUG_PRINT
459         fprintf(stderr, "Serious error: property '%s' not found\n", OUSTRING_CSTR(propName));
460 #endif
461         return rtl::OUString();
462     }
463 
getOriginalProperty(rtl::OUString rPropName,PropertyKind rKind)464     rtl::OUString getOriginalProperty( rtl::OUString rPropName, PropertyKind rKind )
465     {
466         rtl::OUString rValue;
467         switch ( rKind ) {
468             case WINDOW_PROPERTY:
469                 rValue = findProperty( maOriProps, rPropName );
470                 break;
471             case CONTAINER_PROPERTY:
472                 rValue = findProperty( maOriChildProps, rPropName );
473                 break;
474             case WINBITS_PROPERTY:
475                 // TODO
476                 break;
477         }
478 
479         return rValue;
480     }
481 
getProperty(rtl::OUString rPropName,PropertyKind rKind)482     rtl::OUString getProperty( rtl::OUString rPropName, PropertyKind rKind )
483     {
484         rtl::OUString rValue;
485         switch ( rKind ) {
486             case WINDOW_PROPERTY:
487                 rValue = anyToString( layoutimpl::prophlp::getProperty( mxWidget, rPropName ) );
488                 break;
489             case CONTAINER_PROPERTY:
490                 if ( mpParent )
491                     rValue = anyToString( layoutimpl::prophlp::getProperty(
492                                               mpParent->mxContainer->getChildProperties( mxWidget ), rPropName ) );
493                 break;
494             case WINBITS_PROPERTY:
495                 // TODO
496                 break;
497         }
498 
499         return rValue;
500     }
501 
isPropertyTouched(rtl::OUString propName,PropertyKind rKind)502     bool isPropertyTouched( rtl::OUString propName, PropertyKind rKind )
503     {
504         rtl::OUString oriValue = getOriginalProperty( propName, rKind );
505         rtl::OUString newValue = getProperty( propName, rKind );
506         bool isTouched = oriValue != newValue;
507 #if DEBUG_PRINT
508         fprintf(stderr, "is property '%s' touched? %s  (%s vs %s)\n", OUSTRING_CSTR(propName), isTouched ? "yes" : "no", OUSTRING_CSTR(oriValue), OUSTRING_CSTR(newValue));
509 #endif
510         return isTouched;
511     }
512 
513     using LayoutWidget::setProperty;
514 
setProperty(rtl::OUString rPropName,PropertyKind rKind,uno::Any rValue)515     void setProperty( rtl::OUString rPropName, PropertyKind rKind, uno::Any rValue )
516     {
517         switch ( rKind ) {
518             case WINDOW_PROPERTY:
519                 layoutimpl::prophlp::setProperty( mxWidget, rPropName, rValue );
520                 break;
521             case CONTAINER_PROPERTY:
522                 if ( mpParent )
523                     layoutimpl::prophlp::setProperty(
524                         mpParent->mxContainer->getChildProperties( mxWidget ), rPropName, rValue );
525                 break;
526             case WINBITS_PROPERTY:
527                 // TODO
528                 break;
529         }
530     }
531 
532     struct PropertyIterator {
533         friend class Widget;
534         PropertyKind mrKind;
535         uno::Sequence< beans::Property > maProps;
536         int nPropIt;
537 
PropertyIteratorWidget::PropertyIterator538         PropertyIterator( Widget *pWidget, PropertyKind rKind )
539             : mrKind( rKind ), nPropIt( 0 )
540         {
541             switch ( rKind )
542             {
543                 case WINDOW_PROPERTY:
544                     if ( layoutimpl::prophlp::canHandleProps( pWidget->mxWidget ) )
545                     {
546                         uno::Reference< beans::XPropertySetInfo > xInfo
547                             = layoutimpl::prophlp::queryPropertyInfo( pWidget->mxWidget );
548                         if ( !xInfo.is() )
549                             return;
550 
551                         maProps = xInfo->getProperties();
552                     }
553                     break;
554                 case CONTAINER_PROPERTY:
555                     if ( pWidget->mpParent )
556                     {
557                         uno::Reference< beans::XPropertySet >xParentSet(
558                             pWidget->mpParent->mxContainer->getChildProperties( pWidget->mxWidget ) );
559                         if ( xParentSet.is())
560                         {
561                             uno::Reference< beans::XPropertySetInfo > xInfo( xParentSet->getPropertySetInfo() );
562                             if ( xInfo.is() )
563                                 maProps = xInfo->getProperties();
564                         }
565                     }
566                     break;
567                 case WINBITS_PROPERTY:
568                     // TODO
569                     break;
570             }
571         }
572 
hasNextWidget::PropertyIterator573         bool hasNext()
574         {
575             return nPropIt < maProps.getLength();
576         }
577 
nextWidget::PropertyIterator578         beans::Property next()
579         {
580 /*            rtl::OUString propName, propValue;
581               propName = maProps[ nPropIt ];
582               propValue = getProperty( propName, mrKind, false);
583               nPropIt++;
584               return std::pair< rtl::OUString, rtl::OUString > propPair( propName, propValue );*/
585             return maProps[ nPropIt++ ];
586         }
587     };
588 };
589 
590 class EditorRoot : public layoutimpl::LayoutRoot {
591     Widget *mpParent;
592 
593 public:
EditorRoot(const uno::Reference<lang::XMultiServiceFactory> & xFactory,Widget * pParent)594     EditorRoot( const uno::Reference< lang::XMultiServiceFactory >& xFactory,
595                 Widget *pParent )
596         : layoutimpl::LayoutRoot( xFactory ), mpParent( pParent )
597     {
598     }
599 
600     // generation
create(rtl::OUString id,const rtl::OUString unoName,long attrbs,uno::Reference<awt::XLayoutContainer> xParent)601     virtual layoutimpl::LayoutWidget *create( rtl::OUString id, const rtl::OUString unoName,
602                                               long attrbs, uno::Reference< awt::XLayoutContainer > xParent )
603     {
604         if ( unoName.compareToAscii( "dialog" ) == 0 )
605             return mpParent;
606 
607         // TODO: go through specs to map unoName to a more human-readable label
608         Widget *pWidget = new Widget( id, mxToolkit, xParent, unoName, attrbs );
609         if ( !mxWindow.is() )
610             mxWindow = uno::Reference< awt::XWindow >( pWidget->getPeer(), uno::UNO_QUERY );
611 
612         if ( pWidget->mxContainer.is() )
613             pWidget->mxContainer->setLayoutUnit( mpParent->mxContainer->getLayoutUnit() );
614 
615         return pWidget;
616     }
617 };
618 
619 /* Working with the layout in 1D, as if it was a flat list. */
620 namespace FlatLayout
621 {
next(Widget * pWidget)622 Widget *next( Widget *pWidget )
623 {
624     Widget *pNext;
625     pNext = pWidget->down();
626     if ( pNext ) return pNext;
627     pNext = pWidget->next();
628     if ( pNext ) return pNext;
629     for ( Widget *pUp = pWidget->up(); pUp != NULL; pUp = pUp->up() )
630         if ( (pNext = pUp->next()) != NULL )
631             return pNext;
632     return NULL;
633 }
634 
635 /*
636   Widget *prev( Widget *pWidget )
637   {
638   Widget *pPrev;
639   pPrev = pWidget->prev();
640   if ( !pPrev )
641   return pWidget->up();
642 
643   Widget *pBottom = pPrev->down();
644   if ( pBottom )
645   {
646   while ( pBottom->down() || pBottom->next() )
647   {
648   for ( Widget *pNext = pBottom->next(); pNext; pNext = pNext->next() )
649   pBottom = pNext;
650   Widget *pDown = pBottom->down();
651   if ( pDown )
652   pBottom = pDown;
653   }
654   return pBottom;
655   }
656   return pPrev;
657   }
658 */
659 
moveWidget(Widget * pWidget,bool up)660 bool moveWidget( Widget *pWidget, bool up /*or down*/ )
661 {
662     // Keep child parent&pos for in case of failure
663     Widget *pOriContainer = pWidget->up();
664     unsigned int oriChildPos = pOriContainer->getChildPos( pWidget );
665 
666     // Get parent&sibling before removing it, since relations get cut
667     Widget *pSibling = up ? pWidget->prev() : pWidget->next();
668     Widget *pContainer = pWidget->up();
669     if ( !pContainer )
670         return false;
671 
672     // try to swap with parent or child
673     // We need to allow for this at least for the root node...
674     if ( !pSibling )
675     {
676         if ( up )
677         {
678             if ( pContainer->swapWithChild( pWidget ) )
679                 return true;
680         }
681         else
682         {
683 // TODO: this is a nice feature, but we probably want to do it explicitly...
684 #if 0
685             if ( pWidget->down() && pWidget->swapWithChild( pWidget->down() ) )
686                 return true;
687 #endif
688         }
689     }
690 
691     pContainer->removeChild( pWidget );
692 
693     // if has up sibling -- append to it, else swap with it
694     if ( pSibling )
695     {
696         if ( pSibling->addChild( pWidget, up ? 0xffff : 0 ) )
697             return true;
698 
699         unsigned int childPos = pContainer->getChildPos( pSibling );
700         if ( pContainer->addChild( pWidget, childPos + (up ? 0 : 1) ) )
701             return true;  // should always be successful
702     }
703     // go through parents -- try to get prepended to them
704     else
705     {
706         for ( ; pContainer && pContainer->up(); pContainer = pContainer->up() )
707         {
708             unsigned int childPos = pContainer->up()->getChildPos( pContainer );
709             if ( pContainer->up()->addChild( pWidget, childPos + (up ? 0 : 1) ) )
710                 return true;
711         }
712     }
713 
714     // failed -- try to get it to its old position
715     if ( !pOriContainer->addChild( pWidget, oriChildPos ) )
716     {
717         // a parent should never reject a child back. but if it ever
718         // happens, just kill it, we don't run an orphanate here ;P
719         delete pWidget;
720         return true;
721     }
722     return false;
723 }
724 
725 // NOTE: root is considered to be number -1
get(Widget * pRoot,int nb)726 Widget *get( Widget *pRoot, int nb )
727 {
728     Widget *it;
729     for ( it = pRoot; it != NULL && nb >= 0; it = next( it ) )
730         nb--;
731     return it;
732 }
733 
get(Widget * pRoot,Widget * pWidget)734 int get( Widget *pRoot, Widget *pWidget )
735 {
736     int nRet = -1;
737     Widget *it;
738     for ( it = pRoot; it != NULL && it != pWidget; it = next( it ) )
739         nRet++;
740     return nRet;
741 }
742 }
743 
744 //** PropertiesList widget
745 
746 class PropertiesList : public layout::Table
747 {
748     class PropertyEntry
749     {
750         friend class PropertiesList;
751 
752         /* wrapper between the widget and Any */
753         struct AnyWidget
754         {
755             DECL_LINK( ApplyPropertyHdl, layout::Window* );
756             DECL_LINK( FlagToggledHdl, layout::CheckBox* );
757 
AnyWidgetPropertiesList::PropertyEntry::AnyWidget758             AnyWidget( Widget *pWidget, rtl::OUString aPropName, Widget::PropertyKind aPropKind )
759                 : mpWidget( pWidget ), maPropName( aPropName ), maPropKind( aPropKind )
760             {
761                 mpFlag = 0;
762                 mbBlockFlagCallback = false;
763                 bFirstGet = true;
764             }
765 
~AnyWidgetPropertiesList::PropertyEntry::AnyWidget766             virtual ~AnyWidget()
767             {
768 #if DEBUG_PRINT
769                 fprintf(stderr, "~AnyWidget\n");
770 #endif
771             }
772 
savePropertiesList::PropertyEntry::AnyWidget773             void save( uno::Any aValue )
774             {
775                 mpWidget->setProperty( maPropName, maPropKind, aValue );
776                 checkProperty();
777             }
778 
checkPropertyPropertiesList::PropertyEntry::AnyWidget779             void checkProperty()
780             {
781                 bool flag = mpWidget->isPropertyTouched( maPropName, maPropKind );
782 
783                 if ( mpFlag && mpFlag->IsChecked() != (BOOL)flag )
784                 {
785                     CheckFlag( flag, true );
786                 }
787             }
788 
CheckFlagPropertiesList::PropertyEntry::AnyWidget789             void CheckFlag( bool bValue, bool bBlockCallback )
790             {
791                 if ( bBlockCallback )
792                     mbBlockFlagCallback = true;
793                 mpFlag->Check( bValue );
794                 mbBlockFlagCallback = false;
795             }
796 
797             bool bFirstGet;  // HACK
getValuePropertiesList::PropertyEntry::AnyWidget798             rtl::OUString getValue()
799             {
800 //                return mpWidget->getOriProperty( maPropName );
801                 rtl::OUString value;
802                 if ( bFirstGet )    // king of ugliness
803                     value = mpWidget->getProperty( maPropName, maPropKind );
804                 else
805                     value = mpWidget->getOriginalProperty( maPropName, maPropKind );
806                 bFirstGet = false;
807                 return value;
808             }
809 
810             // FIXME: wrapper should have a base class for this...
811             virtual layout::Window *getWindow() = 0;
getContainerPropertiesList::PropertyEntry::AnyWidget812             virtual layout::Container *getContainer() { return NULL; }
813 
814             virtual void load() = 0;
815             virtual void store() = 0;
816 
817             Widget *mpWidget;
818             rtl::OUString maPropName;
819             Widget::PropertyKind maPropKind;
820             layout::CheckBox *mpFlag;
821             bool mbBlockFlagCallback;
822         };
823 
824         struct AnyEdit : public AnyWidget, layout::HBox
825         {
826             layout::Edit *mpEdit;
827             bool mbMultiLine;
828             layout::PushButton *mpExpand;
829             DECL_LINK( ExpandEditHdl, layout::PushButton* );
830 
831             // so we can create widgets (like transforming the Edit into a
832             // MultiLineEdit)
833             layout::Window *mpWinParent;
834 
AnyEditPropertiesList::PropertyEntry::AnyEdit835             AnyEdit( Widget *pWidget, rtl::OUString aPropName,
836                      Widget::PropertyKind aPropKind, layout::Window *pWinParent )
837                 : AnyWidget( pWidget, aPropName, aPropKind ), layout::HBox( 0, false ), mpWinParent( pWinParent )
838             {
839                 mpEdit = NULL;
840                 mpExpand = new layout::PushButton( pWinParent, WB_TOGGLE );
841                 mpExpand->SetToggleHdl( LINK( this, AnyEdit, ExpandEditHdl ) );
842                 setAsMultiLine( false );
843 
844                 load();
845             }
846 
~AnyEditPropertiesList::PropertyEntry::AnyEdit847             virtual ~AnyEdit()
848             {
849                 delete mpEdit;
850                 delete mpExpand;
851             }
852 
getWindowPropertiesList::PropertyEntry::AnyEdit853             virtual layout::Window *getWindow()
854             { return NULL; }
getContainerPropertiesList::PropertyEntry::AnyEdit855             virtual layout::Container *getContainer()
856             { return this; }
857 
setAsMultiLinePropertiesList::PropertyEntry::AnyEdit858             void setAsMultiLine( bool bMultiLine )
859             {
860                 Clear();
861                 XubString text;
862                 if ( mpEdit )
863                 {
864                     text = mpEdit->GetText();
865                     printf("Remove mpEdit and expand\n");
866                     Remove( mpEdit );
867                     Remove( mpExpand );
868                     delete mpEdit;
869                 }
870 
871                 if ( bMultiLine )
872                 {
873                     mpEdit = new layout::Edit( mpWinParent, WB_BORDER );
874                     mpExpand->SetText( String::CreateFromAscii( "-" ) );
875                 }
876                 else
877                 {
878                     mpEdit = new layout::Edit( mpWinParent, WB_BORDER );
879                     mpExpand->SetText( String::CreateFromAscii( "+" ) );
880                 }
881 
882                 mpEdit->SetText( text );
883                 mpEdit->SetModifyHdl( LINK( this, AnyEdit, ApplyPropertyHdl ) );
884 
885                 Add( mpEdit, true, true, 0 );
886                 Add( mpExpand, false, true, 0 );
887 
888                 mbMultiLine = bMultiLine;
889             }
890 
891 #if 0
892             // TODO: make this global... We'll likely need it for export...
893             struct Translate {
894                 const char *ori, *dest;
895             };
896             static rtl::OUString stringReplace( rtl::OUString _str,
897                                                 Translate *trans )
898             {
899                 const sal_Unicode *str = _str.getStr();
900                 rtl::OUStringBuffer buf;
901                 int i, j, k;
902                 for ( i = 0; i < _str.getLength(); i++ )
903                 {
904                     for ( j = 0; trans[ j ].ori; j++ )
905                     {
906                         const char *ori = trans[ j ].ori;
907                         for ( k = 0; ori[ k ] && i+k < _str.getLength(); k++ )
908                             if ( ori[ k ] != str[ i+k ] )
909                                 break;
910                         if ( !ori[ k ] )
911                         {
912                             // found substring
913                             buf.appendAscii( trans[ j ].dest );
914                             i += k;
915                             continue;
916                         }
917                     }
918                     buf.append( str[ i ] );
919                 }
920                 return buf.makeStringAndClear();
921             }
922 #endif
923 
loadPropertiesList::PropertyEntry::AnyEdit924             virtual void load()
925             {
926 #if 0
927                 // replace end of lines by "\\n" strings
928                 Translate trans[] = {
929                     { "\\", "\\\\" }, { "\n", "\\n" }, { 0, 0 }
930                 };
931                 rtl::OUString str = anyToString( getValue() );
932                 str = stringReplace( str, trans );
933                 SetText( str );
934 #endif
935                 mpEdit->SetText( getValue() );
936                 checkProperty();
937             }
938 
storePropertiesList::PropertyEntry::AnyEdit939             virtual void store()
940             {
941 #if 0
942                 // replace "\\n" strings by actual end of lines
943                 Translate trans[] = {
944                     { "\\\\", "\\"  }, { "\\n", "\n" },
945                     { "\\", "" }, { 0, 0 }
946                 };
947                 rtl::OUString str = GetText();
948                 str = stringReplace( str, trans );
949                 save( uno::makeAny( str ) );
950 #endif
951                 save( uno::makeAny( (rtl::OUString) mpEdit->GetText() ) );
952             }
953         };
954 
955         struct AnyInteger : public AnyWidget, NumericField
956         {
AnyIntegerPropertiesList::PropertyEntry::AnyInteger957             AnyInteger( Widget *pWidget, rtl::OUString aPropName,
958                         Widget::PropertyKind aPropKind, Window *pWinParent )
959                 : AnyWidget( pWidget, aPropName, aPropKind ), NumericField( pWinParent, WB_SPIN|WB_BORDER )
960             {
961                 load();
962                 SetModifyHdl( LINK( this, AnyInteger, ApplyPropertyHdl ) );
963             }
964 
getWindowPropertiesList::PropertyEntry::AnyInteger965             virtual Window *getWindow()
966             { return this; }
967 
loadPropertiesList::PropertyEntry::AnyInteger968             virtual void load()
969             {
970                 OUString text = getValue();
971                 SetText( text.getStr() );
972                 checkProperty();
973             }
974 
storePropertiesList::PropertyEntry::AnyInteger975             virtual void store()
976             {
977 #if DEBUG_PRINT
978                 fprintf(stderr, "store number: %ld\n", rtl::OUString( GetText() ).toInt64());
979 #endif
980                 save( uno::makeAny( rtl::OUString( GetText() ).toInt64() ) );
981             }
982         };
983 
984         struct AnyFloat : public AnyInteger
985         {
AnyFloatPropertiesList::PropertyEntry::AnyFloat986             AnyFloat( Widget *pWidget, rtl::OUString aPropName,
987                       Widget::PropertyKind aPropKind, Window *pWinParent )
988                 : AnyInteger( pWidget, aPropName, aPropKind, pWinParent )
989             {}
990 
storePropertiesList::PropertyEntry::AnyFloat991             virtual void store()
992             {
993                 save( uno::makeAny( rtl::OUString( GetText() ).toDouble() ) );
994             }
995         };
996 
997         struct AnyCheckBox : public AnyWidget, layout::CheckBox
998         {
AnyCheckBoxPropertiesList::PropertyEntry::AnyCheckBox999             AnyCheckBox( Widget *pWidget, rtl::OUString aPropName,
1000                          Widget::PropertyKind aPropKind, layout::Window *pWinParent )
1001                 : AnyWidget( pWidget, aPropName, aPropKind ), layout::CheckBox( pWinParent )
1002             {
1003                 // adding some whitespaces to make the hit area larger
1004 //                SetText( String::CreateFromAscii( "" ) );
1005                 load();
1006                 SetToggleHdl( LINK( this, AnyWidget, ApplyPropertyHdl ) );
1007             }
1008 
~AnyCheckBoxPropertiesList::PropertyEntry::AnyCheckBox1009             virtual ~AnyCheckBox()
1010             {
1011 #if DEBUG_PRINT
1012                 fprintf(stderr, "~AnyCheckBox\n");
1013 #endif
1014             }
1015 
getWindowPropertiesList::PropertyEntry::AnyCheckBox1016             virtual layout::Window *getWindow()
1017             { return this; }
1018 
loadPropertiesList::PropertyEntry::AnyCheckBox1019             virtual void load()
1020             {
1021 #if DEBUG_PRINT
1022                 fprintf(stderr, "loading boolean value\n");
1023 #endif
1024                 Check( getValue().toInt64() != 0 );
1025                 setLabel();
1026                 checkProperty();
1027             }
1028 
storePropertiesList::PropertyEntry::AnyCheckBox1029             virtual void store()
1030             {
1031                 save( uno::makeAny( IsChecked() ) );
1032                 setLabel();
1033             }
1034 
setLabelPropertiesList::PropertyEntry::AnyCheckBox1035             void setLabel()
1036             {
1037                 SetText( String::CreateFromAscii( IsChecked() ? "true" : "false" ) );
1038             }
1039         };
1040 
1041         struct AnyListBox : public AnyWidget, layout::ListBox
1042         {
AnyListBoxPropertiesList::PropertyEntry::AnyListBox1043             AnyListBox( Widget *pWidget, rtl::OUString aPropName,
1044                         Widget::PropertyKind aPropKind, Window *pWinParent )
1045                 : AnyWidget( pWidget, aPropName, aPropKind ), layout::ListBox( pWinParent, WB_DROPDOWN )
1046             {
1047                 SetSelectHdl( LINK( this, AnyWidget, ApplyPropertyHdl ) );
1048             }
1049 
getWindowPropertiesList::PropertyEntry::AnyListBox1050             virtual layout::Window *getWindow()
1051             { return this; }
1052 
loadPropertiesList::PropertyEntry::AnyListBox1053             virtual void load()
1054             {
1055                 SelectEntryPos( sal::static_int_cast< USHORT >( getValue().toInt32() ) );
1056                 checkProperty();
1057             }
1058 
storePropertiesList::PropertyEntry::AnyListBox1059             virtual void store()
1060             {
1061                 save( uno::makeAny( (short) GetSelectEntryPos() ) );
1062             }
1063         };
1064 
1065         struct AnyAlign : public AnyListBox
1066         {
AnyAlignPropertiesList::PropertyEntry::AnyAlign1067             AnyAlign( Widget *pWidget, rtl::OUString aPropName,
1068                       Widget::PropertyKind aPropKind, Window *pWinParent )
1069                 : AnyListBox( pWidget, aPropName, aPropKind, pWinParent )
1070             {
1071                 InsertEntry( XubString::CreateFromAscii( "Left" ) );
1072                 InsertEntry( XubString::CreateFromAscii( "Center" ) );
1073                 InsertEntry( XubString::CreateFromAscii( "Right" ) );
1074                 load();
1075             }
1076         };
1077 
1078         /* AnyListBox and AnyComboBox different in that a ComboBox allows the user
1079            to add other options, operating in strings, instead of constants.
1080            (its more like a suggestive AnyEdit) */
1081         struct AnyComboBox : public AnyWidget, layout::ComboBox
1082         {
AnyComboBoxPropertiesList::PropertyEntry::AnyComboBox1083             AnyComboBox( Widget *pWidget, rtl::OUString aPropName,
1084                          Widget::PropertyKind aPropKind, Window *pWinParent )
1085                 : AnyWidget( pWidget, aPropName, aPropKind ), layout::ComboBox( pWinParent, WB_DROPDOWN )
1086             {
1087                 SetModifyHdl( LINK( this, AnyComboBox, ApplyPropertyHdl ) );
1088             }
1089 
getWindowPropertiesList::PropertyEntry::AnyComboBox1090             virtual layout::Window *getWindow()
1091             { return this; }
1092 
loadPropertiesList::PropertyEntry::AnyComboBox1093             virtual void load()
1094             {
1095                 SetText( getValue() );
1096                 checkProperty();
1097             }
1098 
storePropertiesList::PropertyEntry::AnyComboBox1099             virtual void store()
1100             {
1101                 save( uno::makeAny( (rtl::OUString) GetText() ) );
1102             }
1103         };
1104 
1105         struct AnyFontStyle : public AnyComboBox
1106         {
AnyFontStylePropertiesList::PropertyEntry::AnyFontStyle1107             AnyFontStyle( Widget *pWidget, rtl::OUString aPropName,
1108                           Widget::PropertyKind aPropKind, Window *pWinParent )
1109                 : AnyComboBox( pWidget, aPropName, aPropKind, pWinParent )
1110             {
1111                 InsertEntry( XubString::CreateFromAscii( "Bold" ) );
1112                 InsertEntry( XubString::CreateFromAscii( "Italic" ) );
1113                 InsertEntry( XubString::CreateFromAscii( "Bold Italic" ) );
1114                 InsertEntry( XubString::CreateFromAscii( "Fett" ) );
1115                 load();
1116             }
1117         };
1118 
1119         layout::FixedText *mpLabel;
1120         layout::CheckBox *mpFlag;
1121         AnyWidget *mpValue;
1122 
1123     public:
PropertyEntry(layout::Window * pWinParent,AnyWidget * pAnyWidget)1124         PropertyEntry( layout::Window *pWinParent, AnyWidget *pAnyWidget )
1125         {
1126             mpLabel = new layout::FixedText( pWinParent );
1127             {
1128                 // append ':' to aPropName
1129                 rtl::OUStringBuffer buf( pAnyWidget->maPropName );
1130                 buf.append( sal_Unicode (':') );
1131                 mpLabel->SetText( buf.makeStringAndClear() );
1132             }
1133             mpValue = pAnyWidget;
1134             mpFlag = new layout::CheckBox( pWinParent );
1135             mpFlag->SetToggleHdl( LINK( mpValue, AnyWidget, FlagToggledHdl ) );
1136             mpValue->mpFlag = mpFlag;
1137         }
1138 
~PropertyEntry()1139         ~PropertyEntry()
1140         {
1141 #if DEBUG_PRINT
1142                 fprintf(stderr, "REMOVING label, flag and value\n");
1143 #endif
1144             delete mpLabel;
1145             delete mpFlag;
1146             delete mpValue;
1147         }
1148 
1149         // Use this factory rather than the constructor -- check for NULL
construct(Widget * pWidget,rtl::OUString aPropName,Widget::PropertyKind aPropKind,sal_uInt16 nType,layout::Window * pWinParent)1150         static PropertyEntry *construct( Widget *pWidget, rtl::OUString aPropName,
1151                                          Widget::PropertyKind aPropKind, sal_uInt16 nType,
1152                                          layout::Window *pWinParent )
1153         {
1154             AnyWidget *pAnyWidget;
1155             switch (nType) {
1156                 case uno::TypeClass_STRING:
1157                     if ( aPropName.compareToAscii( "FontStyleName" ) == 0 )
1158                     {
1159                         pAnyWidget = new AnyFontStyle( pWidget, aPropName, aPropKind, pWinParent );
1160                         break;
1161                     }
1162                     pAnyWidget = new AnyEdit( pWidget, aPropName, aPropKind, pWinParent );
1163                     break;
1164                 case uno::TypeClass_SHORT:
1165                     if ( aPropName.compareToAscii( "Align" ) == 0 )
1166                     {
1167                         pAnyWidget = new AnyAlign( pWidget, aPropName, aPropKind, pWinParent );
1168                         break;
1169                     }
1170                     // otherwise, treat as any other number...
1171                 case uno::TypeClass_LONG:
1172                 case uno::TypeClass_UNSIGNED_LONG:
1173                     pAnyWidget = new AnyInteger( pWidget, aPropName, aPropKind, pWinParent );
1174                     break;
1175                 case uno::TypeClass_FLOAT:
1176                 case uno::TypeClass_DOUBLE:
1177                     pAnyWidget = new AnyFloat( pWidget, aPropName, aPropKind, pWinParent );
1178                     break;
1179                 case uno::TypeClass_BOOLEAN:
1180                     pAnyWidget = new AnyCheckBox( pWidget, aPropName, aPropKind, pWinParent );
1181                     break;
1182                 default:
1183                     return NULL;
1184             }
1185             return new PropertyEntry( pWinParent, pAnyWidget );
1186         }
1187     };
1188 
1189     layout::Window *mpParentWindow;
1190 
1191     std::list< PropertyEntry* > maPropertiesList;
1192     layout::FixedLine *mpSeparator;
1193 
1194     // some properties are obscure, or simply don't make sense in this
1195     // context. Let's just ignore them.
1196     // Maybe we could offer them in an expander or something...
toIgnore(rtl::OUString prop)1197     static bool toIgnore( rtl::OUString prop )
1198     {
1199         // binary search -- keep the list sorted alphabetically
1200         static char const *toIgnoreList[] = {
1201             "DefaultControl", "FocusOnClick", "FontCharWidth", "FontCharset",
1202             "FontEmphasisMark", "FontFamily", "FontHeight", "FontKerning", "FontName",
1203             "FontOrientation", "FontPitch", "FontRelief", "FontSlant", "FontStrikeout",
1204             "FontType", "FontWordLineMode", "HelpText", "HelpURL", "MultiLine",
1205             "Printable", "Repeat", "RepeatDelay", "Tabstop"
1206         };
1207 
1208 #if 0
1209         // checks list sanity -- enable this when you add some entries...
1210         for ( unsigned int i = 1; i < sizeof( toIgnoreList )/sizeof( char * ); i++ )
1211         {
1212             if ( strcmp(toIgnoreList[i-1], toIgnoreList[i]) >= 0 )
1213             {
1214                 printf("ignore list not ordered properly: "
1215                        "'%s' should come before '%s'\n",
1216                        toIgnoreList[i], toIgnoreList[i-1]);
1217                 exit(-1);
1218             }
1219         }
1220 #endif
1221 
1222         int min = 0, max = sizeof( toIgnoreList )/sizeof( char * ) - 1, mid, cmp;
1223         do {
1224             mid = min + (max - min)/2;
1225             cmp = prop.compareToAscii( toIgnoreList[ mid ] );
1226             if ( cmp > 0 )
1227                 min = mid+1;
1228             else if ( cmp < 0 )
1229                 max = mid-1;
1230             else
1231                 return true;
1232         } while ( min <= max );
1233         return false;
1234     }
1235 
1236 public:
PropertiesList(layout::Dialog * dialog)1237     PropertiesList( layout::Dialog *dialog )
1238         : layout::Table( dialog, "properties-box" )
1239         , mpParentWindow( dialog ), mpSeparator( 0 )
1240     {
1241     }
1242 
~PropertiesList()1243     ~PropertiesList()
1244     {
1245         clear();
1246     }
1247 
1248 private:
1249     // auxiliary, add properties from the peer to the list
addProperties(Widget * pWidget,Widget::PropertyKind rKind)1250     void addProperties( Widget *pWidget, Widget::PropertyKind rKind )
1251     {
1252         Widget::PropertyIterator it( pWidget, rKind );
1253         while ( it.hasNext() )
1254         {
1255             beans::Property prop = it.next();
1256             rtl::OUString name( prop.Name );
1257             if ( toIgnore( name ) )
1258                 continue;
1259             sal_uInt16 type = static_cast< sal_uInt16 >( prop.Type.getTypeClass() );
1260 
1261             PropertyEntry *propEntry = PropertyEntry::construct(
1262                 pWidget, name, rKind, type, mpParentWindow );
1263 
1264             if ( propEntry )
1265             {
1266                 Add( propEntry->mpLabel, false, false );
1267 
1268                 // HACK: one of these will return Null...
1269                 Add( propEntry->mpValue->getWindow(), true, false );
1270                 Add( propEntry->mpValue->getContainer(), true, false );
1271 
1272                 Add( propEntry->mpFlag, false, false );
1273                 maPropertiesList.push_back( propEntry );
1274             }
1275         }
1276     }
1277 
1278 public:
selectedWidget(Widget * pWidget)1279     void selectedWidget( Widget *pWidget )
1280     {
1281         clear();
1282 
1283         if ( !pWidget )
1284             return;
1285 
1286         addProperties( pWidget, Widget::CONTAINER_PROPERTY );
1287 
1288         mpSeparator = new layout::FixedLine( mpParentWindow );
1289         // TODO: we may want to have to separate list widgets here...
1290         Add( mpSeparator, false, false, 3, 1 );
1291 
1292         addProperties( pWidget, Widget::WINDOW_PROPERTY );
1293 
1294         ShowAll( true );
1295     }
1296 
clear()1297     void clear()
1298     {
1299         ///FIXME: crash
1300         Container::Clear();
1301 
1302         for ( std::list< PropertyEntry* >::iterator it = maPropertiesList.begin();
1303               it != maPropertiesList.end(); it++)
1304             delete *it;
1305         maPropertiesList.clear();
1306 
1307         delete mpSeparator;
1308         mpSeparator = NULL;
1309     }
1310 };
1311 
IMPL_LINK(PropertiesList::PropertyEntry::AnyWidget,ApplyPropertyHdl,layout::Window *,pWin)1312 IMPL_LINK( PropertiesList::PropertyEntry::AnyWidget, ApplyPropertyHdl, layout::Window *, pWin )
1313 {
1314     (void) pWin;
1315     store();
1316     return 0;
1317 }
1318 
IMPL_LINK(PropertiesList::PropertyEntry::AnyWidget,FlagToggledHdl,layout::CheckBox *,pCheck)1319 IMPL_LINK( PropertiesList::PropertyEntry::AnyWidget, FlagToggledHdl, layout::CheckBox *, pCheck )
1320 {
1321 #if DEBUG_PRINT
1322     fprintf(stderr, "Property flag pressed -- is: %d\n", pCheck->IsChecked());
1323 #endif
1324     if ( !mbBlockFlagCallback )
1325     {
1326         bool checked = pCheck->IsChecked();
1327         if ( !checked )  // revert
1328         {
1329 #if DEBUG_PRINT
1330             fprintf(stderr, "revert\n");
1331 #endif
1332             load();
1333         }
1334         else
1335         {
1336 #if DEBUG_PRINT
1337             fprintf(stderr, "user can't dirty the flag!\n");
1338 #endif
1339             // User can't flag the property as dirty
1340             // Actually, we may want to allow the designer to force a property to be stored.
1341             // Could be useful when the default value of some new property wasn't yet decided...
1342             CheckFlag( false, true );
1343         }
1344     }
1345 #if DEBUG_PRINT
1346     else
1347         fprintf(stderr, "Property flag pressed -- BLOCKED\n");
1348 #endif
1349     return 0;
1350 }
1351 
IMPL_LINK(PropertiesList::PropertyEntry::AnyEdit,ExpandEditHdl,layout::PushButton *,pBtn)1352 IMPL_LINK( PropertiesList::PropertyEntry::AnyEdit, ExpandEditHdl, layout::PushButton *, pBtn )
1353 {
1354     setAsMultiLine( pBtn->IsChecked() );
1355     return 0;
1356 }
1357 
1358 //** SortListBox auxiliary widget
1359 
1360 class SortListBox
1361 {        // For a manual sort ListBox; asks for a ListBox and Up/Down/Remove
1362          // buttons to wrap
1363     DECL_LINK( ItemSelectedHdl, layout::ListBox* );
1364     DECL_LINK( UpPressedHdl, layout::Button* );
1365     DECL_LINK( DownPressedHdl, layout::Button* );
1366     DECL_LINK( RemovePressedHdl, layout::Button* );
1367     layout::PushButton *mpUpButton, *mpDownButton, *mpRemoveButton;
1368 
1369 protected:
1370     layout::ListBox *mpListBox;
1371 
upPressed(USHORT nPos)1372     virtual void upPressed( USHORT nPos )
1373     {
1374         XubString str = mpListBox->GetSelectEntry();
1375         mpListBox->RemoveEntry( nPos );
1376         nPos = mpListBox->InsertEntry( str, nPos-1 );
1377         mpListBox->SelectEntryPos( nPos );
1378     }
1379 
downPressed(USHORT nPos)1380     virtual void downPressed( USHORT nPos )
1381     {
1382         XubString str = mpListBox->GetSelectEntry();
1383         mpListBox->RemoveEntry( nPos );
1384         nPos = mpListBox->InsertEntry( str, nPos+1 );
1385         mpListBox->SelectEntryPos( nPos );
1386     }
1387 
removePressed(USHORT nPos)1388     virtual void removePressed( USHORT nPos )
1389     {
1390         mpListBox->RemoveEntry( nPos );
1391     }
1392 
itemSelected(USHORT nPos)1393     virtual void itemSelected( USHORT nPos )
1394     {
1395         // if we had some XLayoutContainer::canAdd() or maxChildren() function
1396         // we could make a function to check if we can move selected and enable/
1397         // /disable the move buttons as appropriate
1398 
1399         if ( nPos == LISTBOX_ENTRY_NOTFOUND )
1400         {
1401             mpUpButton->Disable();
1402             mpDownButton->Disable();
1403             mpRemoveButton->Disable();
1404         }
1405         else
1406         {
1407             mpUpButton->Enable();
1408             mpDownButton->Enable();
1409             mpRemoveButton->Enable();
1410         }
1411     }
1412 
1413 public:
SortListBox(layout::ListBox * pListBox,layout::PushButton * pUpButton,layout::PushButton * pDownButton,layout::PushButton * pRemoveButton)1414     SortListBox( layout::ListBox *pListBox, layout::PushButton *pUpButton, layout::PushButton *pDownButton,
1415                  layout::PushButton *pRemoveButton )
1416         : mpUpButton( pUpButton), mpDownButton( pDownButton), mpRemoveButton( pRemoveButton ),
1417           mpListBox( pListBox )
1418     {
1419         mpListBox->SetSelectHdl( LINK( this, SortListBox, ItemSelectedHdl ) );
1420 
1421         mpUpButton->SetModeImage( layout::Image ( "res/commandimagelist/lc_moveup.png" ) );
1422         mpUpButton->SetImageAlign( IMAGEALIGN_LEFT );
1423         mpUpButton->SetClickHdl( LINK( this, SortListBox, UpPressedHdl ) );
1424 
1425         mpDownButton->SetModeImage( layout::Image ( "res/commandimagelist/lc_movedown.png" ) );
1426         mpDownButton->SetImageAlign( IMAGEALIGN_LEFT );
1427         mpDownButton->SetClickHdl( LINK( this, SortListBox, DownPressedHdl ) );
1428 
1429         // "res/commandimagelist/lch_delete.png", "res/commandimagelist/lc_delete.png"
1430         mpRemoveButton->SetModeImage( layout::Image ( "res/commandimagelist/sc_closedoc.png" ) );
1431         mpRemoveButton->SetImageAlign( IMAGEALIGN_LEFT );
1432         mpRemoveButton->SetClickHdl( LINK( this, SortListBox, RemovePressedHdl ) );
1433 
1434         // fire an un-select event
1435         itemSelected( LISTBOX_ENTRY_NOTFOUND );
1436     }
1437 
1438     virtual ~SortListBox();
1439 };
1440 
~SortListBox()1441 SortListBox::~SortListBox()
1442 {
1443     delete mpListBox;
1444     delete mpUpButton;
1445     delete mpDownButton;
1446     delete mpRemoveButton;
1447 }
1448 
IMPL_LINK(SortListBox,UpPressedHdl,layout::Button *,pBtn)1449 IMPL_LINK( SortListBox, UpPressedHdl, layout::Button *, pBtn )
1450 {
1451     (void) pBtn;
1452     USHORT pos = mpListBox->GetSelectEntryPos();
1453     if ( pos > 0 && pos != LISTBOX_ENTRY_NOTFOUND )
1454         upPressed( pos );
1455     return 0;
1456 }
1457 
IMPL_LINK(SortListBox,DownPressedHdl,layout::Button *,pBtn)1458 IMPL_LINK( SortListBox, DownPressedHdl, layout::Button *, pBtn )
1459 {
1460     (void) pBtn;
1461     USHORT pos = mpListBox->GetSelectEntryPos();
1462     if ( pos < mpListBox->GetEntryCount() && pos != LISTBOX_ENTRY_NOTFOUND )
1463         downPressed( pos );
1464     return 0;
1465 }
1466 
IMPL_LINK(SortListBox,RemovePressedHdl,layout::Button *,pBtn)1467 IMPL_LINK( SortListBox, RemovePressedHdl, layout::Button *, pBtn )
1468 {
1469     (void) pBtn;
1470     USHORT pos = mpListBox->GetSelectEntryPos();
1471     if ( pos != LISTBOX_ENTRY_NOTFOUND )
1472         removePressed( pos );
1473     return 0;
1474 }
1475 
IMPL_LINK(SortListBox,ItemSelectedHdl,layout::ListBox *,pList)1476 IMPL_LINK( SortListBox, ItemSelectedHdl, layout::ListBox *, pList )
1477 {
1478     (void) pList;
1479     USHORT pos = mpListBox->GetSelectEntryPos();
1480     itemSelected( pos );
1481     return 0;
1482 }
1483 
1484 //** LayoutTree widget
1485 
1486 class LayoutTree : public SortListBox
1487 {
1488 public:
1489     struct Listener
1490     {
1491         virtual void widgetSelected( Widget *pWidget ) = 0;
1492     };
1493 
1494 private:
1495     Listener *mpListener;
1496 
1497 public:
1498     Widget *mpRootWidget;
1499 
LayoutTree(layout::Dialog * dialog)1500     LayoutTree( layout::Dialog *dialog )
1501         : SortListBox( new layout::ListBox( dialog, "layout-tree" ),
1502                        new layout::PushButton( dialog, "layout-up-button" ),
1503                        new layout::PushButton( dialog, "layout-down-button" ),
1504                        new layout::PushButton( dialog, "layout-remove-button" ) )
1505     {
1506         layout::PeerHandle handle = dialog->GetPeerHandle( "preview-box" );
1507         uno::Reference< awt::XLayoutConstrains > xWidget( handle, uno::UNO_QUERY );
1508         mpRootWidget = new Widget( xWidget, "root" );
1509     }
1510 
1511     virtual ~LayoutTree();
1512 
getWidget(int nPos)1513     Widget *getWidget( int nPos )
1514     {
1515         if ( nPos != LISTBOX_ENTRY_NOTFOUND )
1516             return FlatLayout::get( mpRootWidget, nPos );
1517         return NULL;
1518     }
1519 
getSelectedWidget()1520     Widget *getSelectedWidget()
1521     {
1522         Widget *pWidget = getWidget( mpListBox->GetSelectEntryPos() );
1523         if ( !pWidget )  // return root, if none selected
1524             pWidget = mpRootWidget;
1525         return pWidget;
1526     }
1527 
selectWidget(Widget * pWidget)1528     void selectWidget( Widget *pWidget )
1529     {
1530         int pos = FlatLayout::get( mpRootWidget, pWidget );
1531         if ( pos == -1 )
1532             // if asked to select hidden root, select visible root
1533             pos = 0;
1534         mpListBox->SelectEntryPos( sal::static_int_cast< USHORT >( pos ) );
1535     }
1536 
rebuild()1537     void rebuild()
1538     {
1539         struct inner
1540         {
1541             // pads a string with whitespaces
1542             static rtl::OUString padString( rtl::OUString name, int depth )
1543             {
1544                 rtl::OStringBuffer aBuf( depth * 4 + name.getLength() + 2 );
1545                 for (int i = 0; i < depth; i++)
1546                     aBuf.append( "    " );
1547                 aBuf.append( rtl::OUStringToOString( name, RTL_TEXTENCODING_ASCII_US ) );
1548                 return rtl::OUString( aBuf.getStr(), aBuf.getLength(),
1549                                       RTL_TEXTENCODING_UTF8 );
1550             }
1551         };
1552 
1553         mpListBox->Clear();
1554         for ( Widget *i = FlatLayout::next( mpRootWidget ); i; i = FlatLayout::next( i ) )
1555             mpListBox->InsertEntry( inner::padString( i->getLabel(), i->getDepth()-1 ) );
1556 
1557         // any selection, no longer is. ListBox doesn't fire the event on this case;
1558         // force it.
1559         itemSelected( LISTBOX_ENTRY_NOTFOUND );
1560     }
1561 
setListener(Listener * pListener)1562     void setListener( Listener *pListener )
1563     { mpListener = pListener; }
1564 
1565     // print in XML format...
1566 
toXMLNaming(const rtl::OUString & string)1567     static rtl::OUString toXMLNaming (const rtl::OUString &string)
1568     {
1569         rtl::OUStringBuffer buffer (string.getLength());
1570         sal_Unicode *str = string.pData->buffer;
1571         for (int i = 0; i < string.getLength(); i++) {
1572             if ( str[i] >= 'A' && str[i] <= 'Z' )
1573             {
1574                 if ( i > 0 )
1575                     buffer.append ((sal_Unicode) '-');
1576                 buffer.append ((sal_Unicode) (str[i] - 'A' + 'a'));
1577             }
1578             else
1579                 buffer.append ((sal_Unicode) str[i]);
1580         }
1581 
1582         return buffer.makeStringAndClear();
1583     }
1584 
print()1585     void print()
1586     {
1587         printf("\t\tExport:\n");
1588         printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n"
1589                "<dialog xmlns=\"http://openoffice.org/2007/layout\"\n"
1590                "        xmlns:cnt=\"http://openoffice.org/2007/layout/container\"\n"
1591                "        id=\"dialog\" title=\"Unnamed\" sizeable=\"true\" >\n");
1592 
1593         for ( Widget *i = FlatLayout::next( mpRootWidget ); i; i = FlatLayout::next( i ) )
1594         {
1595             for ( int d = i->getDepth(); d > 0; d-- )
1596                 printf("    ");
1597             printf("<%s ", OUSTRING_CSTR( i->getUnoName() ) );
1598 
1599             for ( int kind = 0; kind < 2; kind++ )
1600             {
1601                 Widget::PropertyKind wKind = kind == 0 ? Widget::WINDOW_PROPERTY
1602                     : Widget::CONTAINER_PROPERTY;
1603                 Widget::PropertyIterator it( i, wKind );
1604                 while ( it.hasNext() )
1605                 {
1606                     beans::Property prop = it.next();
1607                     if ( !i->isPropertyTouched( prop.Name, wKind ) )
1608                         continue;
1609 
1610                     rtl::OUString value = i->getProperty( prop.Name, wKind );
1611                     if ( prop.Type.getTypeClass() == uno::TypeClass_BOOLEAN )
1612                     {
1613                         if ( value.compareToAscii( "0" ) )
1614                             value = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("false") );
1615                         else
1616                             value = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("true") );
1617                     }
1618 
1619                     if ( value.getLength() > 0 )
1620                         printf("%s%s=\"%s\" ",
1621                                kind == 0 ? "" : "cnt:",
1622                                OUSTRING_CSTR( toXMLNaming( prop.Name ) ), OUSTRING_CSTR( value )
1623                             );
1624 
1625                 }
1626             }
1627             printf("/>\n");
1628         }
1629         printf("</dialog>\n");
1630     }
1631 
1632 protected:
upPressed(USHORT nPos)1633     virtual void upPressed( USHORT nPos )
1634     {
1635         Widget *pWidget = getWidget( nPos );
1636         if ( FlatLayout::moveWidget( pWidget, true ) )
1637             rebuild();
1638         selectWidget( pWidget );
1639     }
1640 
downPressed(USHORT nPos)1641     virtual void downPressed( USHORT nPos )
1642     {
1643         Widget *pWidget = getWidget( nPos );
1644         if ( FlatLayout::moveWidget( pWidget, false ) )
1645             rebuild();
1646         selectWidget( pWidget );
1647     }
1648 
removePressed(USHORT nPos)1649     virtual void removePressed( USHORT nPos )
1650     {
1651         Widget *pWidget = getWidget( nPos );
1652         if ( pWidget )
1653         {
1654             pWidget->up()->removeChild( pWidget );
1655             delete pWidget;
1656             rebuild();
1657         }
1658     }
1659 
itemSelected(USHORT nPos)1660     virtual void itemSelected( USHORT nPos )
1661     {
1662         mpListener->widgetSelected( getWidget( nPos ) );
1663         SortListBox::itemSelected( nPos );
1664     }
1665 };
1666 
~LayoutTree()1667 LayoutTree::~LayoutTree()
1668 {
1669     delete mpRootWidget;
1670 }
1671 
1672 //** EditorImpl
1673 
1674 class EditorImpl : public LayoutTree::Listener
1675 {
1676     void createWidget( const char *unoName );
1677 
1678     PropertiesList *mpPropertiesList;
1679     LayoutTree *mpLayoutTree;
1680 
1681     layout::PushButton *pImportButton, *pExportButton;
1682 #ifdef FILEDLG
1683     FileDialog *pImportDialog;
1684 #endif
1685     DECL_LINK( ImportButtonHdl, layout::PushButton* );
1686     DECL_LINK( ExportButtonHdl, layout::PushButton* );
1687 #ifdef FILEDLG
1688     DECL_LINK( ImportDialogHdl, FileDialog* );
1689 #endif
1690 
1691     // framework stuff
1692     uno::Reference< lang::XMultiServiceFactory > mxFactory;
1693     uno::Reference< awt::XToolkit > mxToolkit;
1694     uno::Reference< awt::XWindow > mxToplevel;
1695 
1696     virtual void widgetSelected( Widget *pWidget );
1697     DECL_LINK( CreateWidgetHdl, layout::Button* );
1698 
1699     std::list< layout::PushButton *> maCreateButtons;
1700 
1701 public:
1702 
1703     EditorImpl( layout::Dialog *dialog,
1704                 // we should probable open this channel (or whatever its called) ourselves
1705                 uno::Reference< lang::XMultiServiceFactory > xMSF );
1706     virtual ~EditorImpl();
1707 
1708     void loadFile( const rtl::OUString &aTestFile );
1709 };
1710 
EditorImpl(layout::Dialog * dialog,uno::Reference<lang::XMultiServiceFactory> xFactory)1711 EditorImpl::EditorImpl( layout::Dialog *dialog,
1712                         uno::Reference< lang::XMultiServiceFactory > xFactory )
1713     : mxFactory( xFactory )
1714     , mxToplevel( dialog->GetPeerHandle( "dialog" ), uno::UNO_QUERY )
1715     // FIXME: any of these should work
1716     //dialog->getContext()->getRoot(), uno::UNO_QUERY )
1717     // dialog->GetPeer(), uno::UNO_QUERY )
1718 {
1719 #if DEBUG_PRINT
1720     fprintf (stderr, "EditorImpl()\n");
1721 #endif
1722     // framework
1723     mxToolkit = uno::Reference< awt::XToolkit >(
1724         mxFactory->createInstance(
1725             rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt.Toolkit" ) ) ),
1726         uno::UNO_QUERY );
1727     OSL_ASSERT( mxToolkit.is() );
1728 
1729     // custom widgets
1730 #if DEBUG_PRINT
1731     fprintf (stderr, "custom widgets\n");
1732 #endif
1733     mpPropertiesList = new PropertiesList( dialog );
1734 
1735     mpLayoutTree = new LayoutTree( dialog );
1736     mpLayoutTree->setListener( this );
1737 
1738 /*    if ( xImport.is() )
1739       mpLayoutTree->getWidget( -1 )->addChild( new Widget( xImport, "import" ) );*/
1740 
1741     // create buttons
1742     layout::Container aWidgets( dialog, "create-widget" );
1743     layout::Container aContainers( dialog, "create-container" );
1744     for ( int i = 0; i < WIDGETS_SPECS_LEN; i++ )
1745     {
1746         layout::PushButton *pBtn = new layout::PushButton( (layout::Window *) dialog );
1747         pBtn->SetText( rtl::OUString::createFromAscii( WIDGETS_SPECS[ i ].pLabel ) );
1748         pBtn->SetClickHdl( LINK( this, EditorImpl, CreateWidgetHdl ) );
1749         if ( WIDGETS_SPECS[ i ].pIconName != NULL )
1750         {
1751             rtl::OString aPath ("res/commandimagelist/");
1752             aPath += WIDGETS_SPECS[ i ].pIconName;
1753             layout::Image aImg( aPath );
1754             pBtn->SetModeImage( aImg );
1755             pBtn->SetImageAlign( IMAGEALIGN_LEFT );
1756         }
1757         pBtn->Show();
1758         maCreateButtons.push_back( pBtn );
1759         layout::Container *pBox = WIDGETS_SPECS[ i ].bIsContainer ? &aContainers : &aWidgets;
1760         pBox->Add( pBtn );
1761     }
1762 
1763 #ifdef FILEDLG
1764     fprintf(stderr,"creating file dialog\n");
1765     pImportDialog = new FileDialog( NULL/*(layout::Window *) dialog*/, 0 );
1766     fprintf(stderr,"connecting it\n");
1767     pImportDialog->SetFileSelectHdl( LINK( this, EditorImpl, ImportDialogHdl ) );
1768     fprintf(stderr,"done file dialog\n");
1769 #endif
1770 
1771 /*    pImportButton = new layout::PushButton( dialog, "import-button" );
1772     pImportButton->SetClickHdl( LINK( this, EditorImpl, ImportButtonHdl ) );*/
1773     pExportButton = new layout::PushButton( dialog, "export-button" );
1774     pExportButton->SetClickHdl( LINK( this, EditorImpl, ExportButtonHdl ) );
1775 }
1776 
~EditorImpl()1777 EditorImpl::~EditorImpl()
1778 {
1779     delete mpPropertiesList;
1780     delete mpLayoutTree;
1781     for ( std::list< layout::PushButton * >::const_iterator i = maCreateButtons.begin();
1782           i != maCreateButtons.end(); i++)
1783         delete *i;
1784     delete pImportButton;
1785     delete pExportButton;
1786 #ifdef FILEDLG
1787     delete pImportDialog;
1788 #endif
1789 }
1790 
loadFile(const rtl::OUString & aTestFile)1791 void EditorImpl::loadFile( const rtl::OUString &aTestFile )
1792 {
1793     fprintf( stderr, "TEST: layout instance\n" );
1794     uno::Reference< awt::XLayoutRoot > xRoot
1795         ( new EditorRoot( mxFactory, mpLayoutTree->mpRootWidget ) );
1796 
1797 /*
1798   mxMSF->createInstance
1799   ( ::rtl::OUString::createFromAscii( "com.sun.star.awt.Layout" ) ),
1800   uno::UNO_QUERY );
1801 */
1802     if ( !xRoot.is() )
1803     {
1804         throw uno::RuntimeException(
1805             OUString( RTL_CONSTASCII_USTRINGPARAM("could not create awt Layout component!") ),
1806             uno::Reference< uno::XInterface >() );
1807     }
1808 
1809 #if DEBUG_PRINT
1810     fprintf( stderr, "TEST: initing root\n" );
1811 #endif
1812 
1813     uno::Reference< lang::XInitialization > xInit( xRoot, uno::UNO_QUERY );
1814     if ( !xInit.is() )
1815     {
1816         throw uno::RuntimeException(
1817             OUString( RTL_CONSTASCII_USTRINGPARAM("Layout has no XInitialization!") ),
1818             uno::Reference< uno::XInterface >() );
1819     }
1820 
1821 #if DEBUG_PRINT
1822     fprintf( stderr, "TEST: running parser\n" );
1823 #endif
1824     uno::Sequence< uno::Any > aParams( 1 );
1825     aParams[0] <<= aTestFile;
1826 #if DEBUG_PRINT
1827     fprintf( stderr, "TEST: do it\n" );
1828 #endif
1829     xInit->initialize( aParams );
1830 #if DEBUG_PRINT
1831     fprintf( stderr, "TEST: file loaded\n" );
1832 #endif
1833 
1834     mpLayoutTree->rebuild();
1835 }
1836 
createWidget(const char * name)1837 void EditorImpl::createWidget( const char *name )
1838 {
1839     Widget *pWidget = mpLayoutTree->getSelectedWidget();
1840 
1841     Widget *pChild = new Widget( rtl::OUString(), mxToolkit, uno::Reference< awt::XLayoutContainer >( mxToplevel, uno::UNO_QUERY ), rtl::OUString::createFromAscii( name ), awt::WindowAttribute::SHOW );
1842     if ( !pWidget->addChild( pChild ) )
1843     {
1844         delete pChild;
1845         // we may want to popup an error message
1846     }
1847     else
1848     {
1849         mpLayoutTree->rebuild();
1850         mpLayoutTree->selectWidget( pWidget );
1851     }
1852 }
1853 
widgetSelected(Widget * pWidget)1854 void EditorImpl::widgetSelected( Widget *pWidget )
1855 {
1856     // we know can't add widget to a non-container, so let's disable the create
1857     // buttons then. Would be nice to have a method to check if a container is
1858     // full as well...
1859     if ( !pWidget || pWidget->isContainer() )
1860     {
1861         for ( std::list< layout::PushButton *>::const_iterator it = maCreateButtons.begin();
1862               it != maCreateButtons.end(); it++)
1863             (*it)->Enable();
1864     }
1865     else
1866     {
1867         for ( std::list< layout::PushButton *>::const_iterator it = maCreateButtons.begin();
1868               it != maCreateButtons.end(); it++)
1869             (*it)->Disable();
1870     }
1871 
1872     mpPropertiesList->selectedWidget( pWidget );
1873 }
1874 
IMPL_LINK(EditorImpl,CreateWidgetHdl,layout::Button *,pBtn)1875 IMPL_LINK( EditorImpl, CreateWidgetHdl, layout::Button *, pBtn )
1876 {
1877     int i = 0;
1878     for ( std::list< layout::PushButton *>::const_iterator it = maCreateButtons.begin();
1879           it != maCreateButtons.end(); it++, i++ )
1880     {
1881         if ( pBtn == *it )
1882             break;
1883     }
1884     OSL_ASSERT( i < WIDGETS_SPECS_LEN );
1885     createWidget( WIDGETS_SPECS[i].pName );
1886     return 0;
1887 }
1888 
IMPL_LINK(EditorImpl,ImportButtonHdl,layout::PushButton *,pBtn)1889 IMPL_LINK( EditorImpl, ImportButtonHdl, layout::PushButton *, pBtn )
1890 {
1891     (void) pBtn;
1892 #if DEBUG_PRINT
1893     fprintf(stderr, "IMPORT!\n");
1894 #endif
1895 #ifdef FILEDLG
1896     pImportDialog->Execute();
1897 #endif
1898 
1899     return 0;
1900 }
1901 
1902 #ifdef FILEDLG
IMPL_LINK(EditorImpl,ImportDialogHdl,FileDialog *,pDialog)1903 IMPL_LINK( EditorImpl, ImportDialogHdl, FileDialog *, pDialog )
1904 {
1905     UniString path = pDialog->GetPath();
1906 //fprintf(stderr, "Executing import dialog!\n");
1907 
1908 #if DEBUG_PRINT
1909     fprintf(stderr, "got import file: %s\n",rtl::OUStringToOString( path, RTL_TEXTENCODING_ASCII_US ).getStr() );
1910 #endif
1911 
1912     return 0;
1913 }
1914 #endif
1915 
IMPL_LINK(EditorImpl,ExportButtonHdl,layout::PushButton *,pBtn)1916 IMPL_LINK( EditorImpl, ExportButtonHdl, layout::PushButton *, pBtn )
1917 {
1918     (void) pBtn;
1919     mpLayoutTree->print();
1920     return 0;
1921 }
1922 
1923 //** Editor, the Dialog
1924 
Editor(uno::Reference<lang::XMultiServiceFactory> xFactory,rtl::OUString aFile)1925 Editor::Editor( uno::Reference< lang::XMultiServiceFactory > xFactory,
1926                 rtl::OUString aFile )
1927     : layout::Dialog( (Window*) (NULL), "editor.xml", "dialog" )
1928     , mpImpl( new EditorImpl( this, xFactory ) )
1929 {
1930     if ( aFile.getLength() )
1931         mpImpl->loadFile( aFile );
1932 
1933     // parent:
1934     FreeResource();
1935 }
1936 
~Editor()1937 Editor::~Editor()
1938 {
1939     delete mpImpl;
1940 }
1941