| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| #include "editor.hxx" |
| |
| #undef NDEBUG |
| |
| /* |
| #include <stdio.h> |
| #include <string.h> |
| */ |
| |
| #include <cassert> |
| #include <cstdio> |
| #include <cstring> |
| #include <list> |
| #include <vector> |
| |
| #include <com/sun/star/awt/WindowAttribute.hpp> |
| #include <com/sun/star/awt/XLayoutConstrains.hpp> |
| #include <com/sun/star/awt/XLayoutContainer.hpp> |
| #include <com/sun/star/awt/XToolkit.hpp> |
| #include <com/sun/star/awt/XVclWindowPeer.hpp> |
| #include <com/sun/star/awt/XWindow.hpp> |
| #include <com/sun/star/awt/XWindowPeer.hpp> |
| #include <rtl/strbuf.hxx> |
| #include <rtl/ustrbuf.hxx> |
| #include <toolkit/helper/property.hxx> |
| #include <vcl/lstbox.h> |
| |
| using namespace layout::css; |
| |
| using rtl::OUString; |
| |
| // FIXME: |
| //#define FILEDLG |
| |
| #include <layout/core/helper.hxx> |
| #include <layout/core/root.hxx> |
| #include <layout/core/helper.hxx> |
| |
| // TODO: automatically generated |
| struct WidgetSpec { |
| const char *pLabel, *pName, *pIconName; |
| bool bIsContainer; }; |
| static const WidgetSpec WIDGETS_SPECS[] = { |
| { "Label", "fixedtext" , "sc_label.png", false }, |
| { "Button", "pushbutton" , "sc_pushbutton.png", false }, |
| { "Radio Button", "radiobutton" , "sc_radiobutton.png", false }, |
| { "Check Box", "checkbox" , "sc_checkbox.png", false }, |
| { "Line Edit", "edit" , "sc_edit.png", false }, |
| { "Numeric Field", "numericfield", "sc_numericfield.png", false }, |
| { "List Box ", "listbox" , NULL, false }, |
| // containers |
| { "Hor Box", "hbox" , NULL, true }, |
| { "Ver Box", "vbox" , NULL, true }, |
| { "Table", "table" , NULL, true }, |
| { "Alignment", "align" , NULL, true }, |
| { "Tab Control", "tabcontrol" , NULL, true }, |
| { "Hor Splitter", "hsplitter" , NULL, true }, |
| { "Ver Splitter", "vsplitter" , NULL, true }, |
| { "Scroller", "scroller" , NULL, true }, |
| }; |
| const int WIDGETS_SPECS_LEN = sizeof (WIDGETS_SPECS) / sizeof (WidgetSpec); |
| |
| using namespace layout; |
| using namespace layoutimpl; |
| namespace css = ::com::sun::star; |
| |
| static rtl::OUString anyToString (uno::Any value) |
| { |
| try |
| { |
| switch (value.getValueTypeClass()) { |
| case uno::TypeClass_STRING: |
| return value.get<rtl::OUString>(); |
| case uno::TypeClass_CONSTANT: |
| return rtl::OUString::valueOf (value.get<sal_Int32>()); |
| case uno::TypeClass_LONG: |
| return rtl::OUString::valueOf (value.get<sal_Int64>()); |
| case uno::TypeClass_SHORT: |
| // FIXME: seems broken |
| return rtl::OUString::valueOf ((sal_Int32) value.get<short>()); |
| |
| case uno::TypeClass_FLOAT: |
| return rtl::OUString::valueOf (value.get<float>()); |
| case uno::TypeClass_DOUBLE: |
| return rtl::OUString::valueOf (value.get<double>()); |
| |
| case uno::TypeClass_BOOLEAN: |
| { |
| bool val = value.get<sal_Bool>(); |
| return rtl::OUString( val ? "1" : "0", 1, RTL_TEXTENCODING_ASCII_US ); |
| /* if ( val ) |
| return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "true" ) ); |
| else |
| return rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "false" ) );*/ |
| } |
| default: |
| break; |
| } |
| } |
| catch(...) {} |
| return rtl::OUString(); |
| } |
| |
| static inline long anyToNatural (uno::Any value) |
| { return sal::static_int_cast<long>(anyToString( value ).toInt64()); } |
| static inline double anyToDecimal (uno::Any value) |
| { return anyToString( value ).toDouble(); } |
| |
| /* XLayoutContainer/XLayoutConstrains are a bit of a hasle to work with. |
| Let's wrap them. */ |
| class Widget : public layoutimpl::LayoutWidget |
| { |
| friend class EditorRoot; |
| |
| Widget *mpParent; |
| std::vector< Widget *> maChildren; |
| bool mbForeign; |
| |
| rtl::OUString mrId; |
| rtl::OUString mrLabel, mrUnoName; |
| |
| // TODO: store original properties. And some property handling methods. |
| long mnOriAttrbs; |
| layoutimpl::PropList maOriProps, maOriChildProps; |
| |
| public: |
| |
| // to be used to wrap the root |
| Widget( uno::Reference< awt::XLayoutConstrains > xImport, const char *label ) |
| : mpParent( 0 ), mbForeign( true ) |
| { |
| mxWidget = xImport; |
| mxContainer = uno::Reference< awt::XLayoutContainer >( mxWidget, uno::UNO_QUERY ); |
| |
| mrLabel = rtl::OUString( label, strlen( label ), RTL_TEXTENCODING_UTF8 ); |
| |
| #if 0 /* obsolete */ |
| // FIXME: this code is meant to import a XML file. Just use the importer, |
| // then pass the root widget. But information like the ID string is lost. |
| // So, this needs to be more closely tight to the importer. |
| uno::Sequence< uno::Reference< awt::XLayoutConstrains > > aChildren; |
| for ( int i = 0; i < aChildren.getLength(); i++ ) |
| { |
| Widget *pChild = new Widget( aChildren[ i ], "---" ); |
| maChildren.push_back( pChild ); |
| pChild->mpParent = this; |
| } |
| #endif |
| } |
| |
| Widget( rtl::OUString id, uno::Reference< awt::XToolkit > xToolkit, |
| uno::Reference< awt::XLayoutContainer > xParent, |
| rtl::OUString unoName, long nAttrbs ) |
| : mpParent( 0 ), mbForeign( false ), mrId( id ), |
| mnOriAttrbs( nAttrbs ) |
| { |
| while ( xParent.is() && !uno::Reference< awt::XWindow >( xParent, uno::UNO_QUERY ).is() ) |
| { |
| uno::Reference< awt::XLayoutContainer > xContainer( xParent, uno::UNO_QUERY ); |
| OSL_ASSERT( xContainer.is() ); |
| xParent = uno::Reference< awt::XLayoutContainer >( xContainer->getParent(), uno::UNO_QUERY ); |
| } |
| |
| mxWidget = WidgetFactory::createWidget( xToolkit, xParent, unoName, nAttrbs ); |
| OSL_ASSERT( mxWidget.is() ); |
| mxContainer = uno::Reference< awt::XLayoutContainer >( mxWidget, uno::UNO_QUERY ); |
| |
| mrLabel = mrUnoName = unoName; |
| // try to get a nicer label for the widget |
| for ( int i = 0; i < WIDGETS_SPECS_LEN; i++ ) |
| if ( unoName.equalsAscii( WIDGETS_SPECS[ i ].pName ) ) |
| { |
| const char *label = WIDGETS_SPECS[ i ].pLabel; |
| mrLabel = rtl::OUString( label, strlen( label ), RTL_TEXTENCODING_UTF8 ); |
| break; |
| } |
| |
| // set default Text property |
| // TODO: disable editing of text fields, check boxes selected, etc... |
| #if 0 |
| uno::Reference< awt::XVclWindowPeer> xVclPeer( mxWidget, uno::UNO_QUERY ) |
| if ( xVclPeer.is() ) // XVclWindowPeer ignores missing / incorrect properties |
| |
| //FIXME: it looks odd on widgets like NumericField seeing text which is deleted |
| // when you interact with it... We can avoid it for those widgets, by doing a getProp |
| // of "Text" and check if it is empty or not. |
| |
| xVclPeer->setProperty( rtl::OUString::createFromAscii( "Text" ), |
| uno::makeAny( rtl::OUString::createFromAscii( "new widget" ) ) ); |
| #endif |
| |
| // store original properties |
| { |
| PropertyIterator it( this, WINDOW_PROPERTY ); |
| while ( it.hasNext() ) |
| { |
| beans::Property prop = it.next(); |
| rtl::OUString name( prop.Name ); |
| rtl::OUString value( getProperty( name, WINDOW_PROPERTY ) ); |
| #if DEBUG_PRINT |
| fprintf(stderr, "original property: %s = %s\n", OUSTRING_CSTR(name), OUSTRING_CSTR(value)); |
| #endif |
| std::pair< rtl::OUString, rtl::OUString > pair( name, value ); |
| maOriProps.push_back( pair ); |
| } |
| } |
| |
| } |
| |
| ~Widget() |
| { |
| for ( std::vector< Widget *>::const_iterator it = maChildren.begin(); |
| it != maChildren.end(); it++ ) |
| delete *it; |
| if ( !mbForeign ) |
| { |
| uno::Reference< lang::XComponent > xComp( mxWidget, uno::UNO_QUERY ); |
| if ( xComp.is() ) |
| // some widgets, like our containers, don't implement this interface... |
| xComp->dispose(); |
| } |
| } |
| |
| uno::Reference< awt::XLayoutConstrains > impl() |
| { |
| return mxWidget; |
| } |
| |
| // LayoutWidget |
| virtual bool addChild( LayoutWidget *pChild ) |
| { |
| return addChild( static_cast< Widget * >( pChild ) ); |
| } |
| |
| virtual void setProperties( const PropList &rProps ) |
| { |
| // maOriProps = rProps; |
| LayoutWidget::setProperties( rProps ); |
| } |
| |
| virtual void setChildProperties( LayoutWidget *pChild, const PropList &rProps ) |
| { |
| maOriChildProps = rProps; |
| LayoutWidget::setChildProperties( pChild, rProps ); |
| } |
| |
| // tree travel |
| Widget *up() |
| { |
| return mpParent; |
| } |
| |
| Widget *down() |
| { |
| if ( maChildren.empty() ) |
| return NULL; |
| return maChildren.front(); |
| } |
| |
| Widget *next() |
| { |
| if ( mpParent ) |
| { |
| int pos = mpParent->getChildPos( this ); |
| return mpParent->getChild( pos+1 ); |
| } |
| return NULL; |
| } |
| |
| Widget *prev() |
| { |
| if ( mpParent ) |
| { |
| int pos = mpParent->getChildPos( this ); |
| return mpParent->getChild( pos-1 ); |
| } |
| return NULL; |
| } |
| |
| // handle |
| bool addChild( Widget *pChild, int pos = 0xffff ) |
| { |
| if ( !mxContainer.is() ) |
| return false; |
| |
| uno::Sequence< uno::Reference < awt::XLayoutConstrains > > aChildren; |
| aChildren = mxContainer->getChildren(); |
| int nChildrenLen = aChildren.getLength(); |
| |
| // ugly, but let's check if the container is next to full... |
| try { |
| mxContainer->addChild( pChild->mxWidget ); |
| } |
| catch( awt::MaxChildrenException ex ) { |
| return false; |
| } |
| |
| if ( pos < nChildrenLen ) |
| { // if its on the middle, we need to make space for it |
| mxContainer->removeChild( pChild->mxWidget ); |
| for ( int i = pos; i < nChildrenLen; i++ ) |
| mxContainer->removeChild( aChildren[ i ] ); |
| mxContainer->addChild( pChild->mxWidget ); |
| for ( int i = pos; i < nChildrenLen; i++ ) |
| mxContainer->addChild( aChildren[ i ] ); |
| maChildren.insert( maChildren.begin()+pos, pChild ); |
| } |
| else |
| maChildren.push_back( pChild ); |
| |
| OSL_ASSERT( pChild->mpParent == NULL ); |
| pChild->mpParent = this; |
| |
| // store container props |
| { |
| pChild->maOriChildProps.clear(); |
| PropertyIterator it( pChild, CONTAINER_PROPERTY ); |
| while ( it.hasNext() ) |
| { |
| beans::Property prop = it.next(); |
| rtl::OUString name( prop.Name ); |
| try { |
| rtl::OUString value( pChild->getProperty( name, CONTAINER_PROPERTY ) ); |
| std::pair< rtl::OUString, rtl::OUString > pair( name, value ); |
| pChild->maOriChildProps.push_back( pair ); |
| } catch ( beans::UnknownPropertyException &rEx ) { |
| 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", |
| rtl::OUStringToOString (rEx.Message, RTL_TEXTENCODING_UTF8).getStr()); |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| bool removeChild( Widget *pChild ) |
| { |
| if ( !mxContainer.is() || pChild->mpParent != this ) |
| return false; |
| |
| mxContainer->removeChild( pChild->mxWidget ); |
| |
| unsigned int pos = getChildPos( pChild ); |
| if ( pos < maChildren.size() ) |
| maChildren.erase( maChildren.begin()+pos ); |
| pChild->mpParent = NULL; |
| |
| return true; |
| } |
| |
| bool swapWithChild( Widget *pChild ) |
| { |
| if ( !pChild->isContainer() ) |
| return false; |
| |
| // remove all child's childrens, and try to add them here |
| removeChild( pChild ); |
| |
| // keep a copy for failure |
| std::vector< Widget *> aChildren = maChildren; |
| std::vector< Widget *> aChildChildren = pChild->maChildren; |
| |
| for ( std::vector< Widget *>::const_iterator it = aChildChildren.begin(); |
| it != aChildChildren.end(); it++ ) |
| pChild->removeChild( *it ); |
| |
| for ( std::vector< Widget *>::const_iterator it = aChildChildren.begin(); |
| it != aChildChildren.end(); it++ ) |
| if ( !addChild( *it ) ) |
| { // failure |
| for ( std::vector< Widget *>::const_iterator jt = aChildChildren.begin(); |
| jt != it; jt++ ) |
| removeChild( *jt ); |
| for ( std::vector< Widget *>::const_iterator jt = aChildChildren.begin(); |
| jt != aChildChildren.end(); jt++ ) |
| pChild->addChild( *jt ); |
| return false; |
| } |
| |
| Widget *pParent = up(); |
| |
| if ( pParent ) |
| { |
| pParent->removeChild( this ); |
| pParent->addChild( pChild ); |
| } |
| pChild->addChild( this ); |
| return true; |
| } |
| |
| unsigned int getChildPos( Widget *pChild ) |
| { |
| int i = 0; |
| for ( std::vector< Widget *>::const_iterator it = maChildren.begin(); |
| it != maChildren.end(); it++, i++ ) |
| if ( *it == pChild ) |
| break; |
| return i; |
| } |
| |
| Widget *getChild( int pos ) |
| { |
| if ( pos >= 0 && pos < (signed) maChildren.size() ) |
| return *(maChildren.begin() + pos); |
| return NULL; |
| } |
| |
| bool isContainer() |
| { return mxContainer.is(); } |
| unsigned int getChildrenLen() |
| { return maChildren.size(); } |
| |
| rtl::OUString getLabel() const |
| { return mrLabel; } |
| rtl::OUString getUnoName() const |
| { return mrUnoName; } |
| |
| int getDepth() |
| { |
| int depth = 0; |
| for ( Widget *pWidget = mpParent; pWidget; pWidget = pWidget->mpParent ) |
| depth++; |
| return depth; |
| } |
| |
| enum PropertyKind { |
| WINDOW_PROPERTY, CONTAINER_PROPERTY, WINBITS_PROPERTY |
| }; |
| |
| static rtl::OUString findProperty( const PropList &props, rtl::OUString propName ) |
| { |
| for ( PropList::const_iterator it = props.begin(); it != props.end(); it++ ) |
| if ( it->first.equalsIgnoreAsciiCase( propName ) ) |
| return it->second; |
| #if DEBUG_PRINT |
| fprintf(stderr, "Serious error: property '%s' not found\n", OUSTRING_CSTR(propName)); |
| #endif |
| return rtl::OUString(); |
| } |
| |
| rtl::OUString getOriginalProperty( rtl::OUString rPropName, PropertyKind rKind ) |
| { |
| rtl::OUString rValue; |
| switch ( rKind ) { |
| case WINDOW_PROPERTY: |
| rValue = findProperty( maOriProps, rPropName ); |
| break; |
| case CONTAINER_PROPERTY: |
| rValue = findProperty( maOriChildProps, rPropName ); |
| break; |
| case WINBITS_PROPERTY: |
| // TODO |
| break; |
| } |
| |
| return rValue; |
| } |
| |
| rtl::OUString getProperty( rtl::OUString rPropName, PropertyKind rKind ) |
| { |
| rtl::OUString rValue; |
| switch ( rKind ) { |
| case WINDOW_PROPERTY: |
| rValue = anyToString( layoutimpl::prophlp::getProperty( mxWidget, rPropName ) ); |
| break; |
| case CONTAINER_PROPERTY: |
| if ( mpParent ) |
| rValue = anyToString( layoutimpl::prophlp::getProperty( |
| mpParent->mxContainer->getChildProperties( mxWidget ), rPropName ) ); |
| break; |
| case WINBITS_PROPERTY: |
| // TODO |
| break; |
| } |
| |
| return rValue; |
| } |
| |
| bool isPropertyTouched( rtl::OUString propName, PropertyKind rKind ) |
| { |
| rtl::OUString oriValue = getOriginalProperty( propName, rKind ); |
| rtl::OUString newValue = getProperty( propName, rKind ); |
| bool isTouched = oriValue != newValue; |
| #if DEBUG_PRINT |
| fprintf(stderr, "is property '%s' touched? %s (%s vs %s)\n", OUSTRING_CSTR(propName), isTouched ? "yes" : "no", OUSTRING_CSTR(oriValue), OUSTRING_CSTR(newValue)); |
| #endif |
| return isTouched; |
| } |
| |
| using LayoutWidget::setProperty; |
| |
| void setProperty( rtl::OUString rPropName, PropertyKind rKind, uno::Any rValue ) |
| { |
| switch ( rKind ) { |
| case WINDOW_PROPERTY: |
| layoutimpl::prophlp::setProperty( mxWidget, rPropName, rValue ); |
| break; |
| case CONTAINER_PROPERTY: |
| if ( mpParent ) |
| layoutimpl::prophlp::setProperty( |
| mpParent->mxContainer->getChildProperties( mxWidget ), rPropName, rValue ); |
| break; |
| case WINBITS_PROPERTY: |
| // TODO |
| break; |
| } |
| } |
| |
| struct PropertyIterator { |
| friend class Widget; |
| PropertyKind mrKind; |
| uno::Sequence< beans::Property > maProps; |
| int nPropIt; |
| |
| PropertyIterator( Widget *pWidget, PropertyKind rKind ) |
| : mrKind( rKind ), nPropIt( 0 ) |
| { |
| switch ( rKind ) |
| { |
| case WINDOW_PROPERTY: |
| if ( layoutimpl::prophlp::canHandleProps( pWidget->mxWidget ) ) |
| { |
| uno::Reference< beans::XPropertySetInfo > xInfo |
| = layoutimpl::prophlp::queryPropertyInfo( pWidget->mxWidget ); |
| if ( !xInfo.is() ) |
| return; |
| |
| maProps = xInfo->getProperties(); |
| } |
| break; |
| case CONTAINER_PROPERTY: |
| if ( pWidget->mpParent ) |
| { |
| uno::Reference< beans::XPropertySet >xParentSet( |
| pWidget->mpParent->mxContainer->getChildProperties( pWidget->mxWidget ) ); |
| if ( xParentSet.is()) |
| { |
| uno::Reference< beans::XPropertySetInfo > xInfo( xParentSet->getPropertySetInfo() ); |
| if ( xInfo.is() ) |
| maProps = xInfo->getProperties(); |
| } |
| } |
| break; |
| case WINBITS_PROPERTY: |
| // TODO |
| break; |
| } |
| } |
| |
| bool hasNext() |
| { |
| return nPropIt < maProps.getLength(); |
| } |
| |
| beans::Property next() |
| { |
| /* rtl::OUString propName, propValue; |
| propName = maProps[ nPropIt ]; |
| propValue = getProperty( propName, mrKind, false); |
| nPropIt++; |
| return std::pair< rtl::OUString, rtl::OUString > propPair( propName, propValue );*/ |
| return maProps[ nPropIt++ ]; |
| } |
| }; |
| }; |
| |
| class EditorRoot : public layoutimpl::LayoutRoot { |
| Widget *mpParent; |
| |
| public: |
| EditorRoot( const uno::Reference< lang::XMultiServiceFactory >& xFactory, |
| Widget *pParent ) |
| : layoutimpl::LayoutRoot( xFactory ), mpParent( pParent ) |
| { |
| } |
| |
| // generation |
| virtual layoutimpl::LayoutWidget *create( rtl::OUString id, const rtl::OUString unoName, |
| long attrbs, uno::Reference< awt::XLayoutContainer > xParent ) |
| { |
| if ( unoName.compareToAscii( "dialog" ) == 0 ) |
| return mpParent; |
| |
| // TODO: go through specs to map unoName to a more human-readable label |
| Widget *pWidget = new Widget( id, mxToolkit, xParent, unoName, attrbs ); |
| if ( !mxWindow.is() ) |
| mxWindow = uno::Reference< awt::XWindow >( pWidget->getPeer(), uno::UNO_QUERY ); |
| |
| if ( pWidget->mxContainer.is() ) |
| pWidget->mxContainer->setLayoutUnit( mpParent->mxContainer->getLayoutUnit() ); |
| |
| return pWidget; |
| } |
| }; |
| |
| /* Working with the layout in 1D, as if it was a flat list. */ |
| namespace FlatLayout |
| { |
| Widget *next( Widget *pWidget ) |
| { |
| Widget *pNext; |
| pNext = pWidget->down(); |
| if ( pNext ) return pNext; |
| pNext = pWidget->next(); |
| if ( pNext ) return pNext; |
| for ( Widget *pUp = pWidget->up(); pUp != NULL; pUp = pUp->up() ) |
| if ( (pNext = pUp->next()) != NULL ) |
| return pNext; |
| return NULL; |
| } |
| |
| /* |
| Widget *prev( Widget *pWidget ) |
| { |
| Widget *pPrev; |
| pPrev = pWidget->prev(); |
| if ( !pPrev ) |
| return pWidget->up(); |
| |
| Widget *pBottom = pPrev->down(); |
| if ( pBottom ) |
| { |
| while ( pBottom->down() || pBottom->next() ) |
| { |
| for ( Widget *pNext = pBottom->next(); pNext; pNext = pNext->next() ) |
| pBottom = pNext; |
| Widget *pDown = pBottom->down(); |
| if ( pDown ) |
| pBottom = pDown; |
| } |
| return pBottom; |
| } |
| return pPrev; |
| } |
| */ |
| |
| bool moveWidget( Widget *pWidget, bool up /*or down*/ ) |
| { |
| // Keep child parent&pos for in case of failure |
| Widget *pOriContainer = pWidget->up(); |
| unsigned int oriChildPos = pOriContainer->getChildPos( pWidget ); |
| |
| // Get parent&sibling before removing it, since relations get cut |
| Widget *pSibling = up ? pWidget->prev() : pWidget->next(); |
| Widget *pContainer = pWidget->up(); |
| if ( !pContainer ) |
| return false; |
| |
| // try to swap with parent or child |
| // We need to allow for this at least for the root node... |
| if ( !pSibling ) |
| { |
| if ( up ) |
| { |
| if ( pContainer->swapWithChild( pWidget ) ) |
| return true; |
| } |
| else |
| { |
| // TODO: this is a nice feature, but we probably want to do it explicitely... |
| #if 0 |
| if ( pWidget->down() && pWidget->swapWithChild( pWidget->down() ) ) |
| return true; |
| #endif |
| } |
| } |
| |
| pContainer->removeChild( pWidget ); |
| |
| // if has up sibling -- append to it, else swap with it |
| if ( pSibling ) |
| { |
| if ( pSibling->addChild( pWidget, up ? 0xffff : 0 ) ) |
| return true; |
| |
| unsigned int childPos = pContainer->getChildPos( pSibling ); |
| if ( pContainer->addChild( pWidget, childPos + (up ? 0 : 1) ) ) |
| return true; // should always be succesful |
| } |
| // go through parents -- try to get prepended to them |
| else |
| { |
| for ( ; pContainer && pContainer->up(); pContainer = pContainer->up() ) |
| { |
| unsigned int childPos = pContainer->up()->getChildPos( pContainer ); |
| if ( pContainer->up()->addChild( pWidget, childPos + (up ? 0 : 1) ) ) |
| return true; |
| } |
| } |
| |
| // failed -- try to get it to its old position |
| if ( !pOriContainer->addChild( pWidget, oriChildPos ) ) |
| { |
| // a parent should never reject a child back. but if it ever |
| // happens, just kill it, we don't run an orphanate here ;P |
| delete pWidget; |
| return true; |
| } |
| return false; |
| } |
| |
| // NOTE: root is considered to be number -1 |
| Widget *get( Widget *pRoot, int nb ) |
| { |
| Widget *it; |
| for ( it = pRoot; it != NULL && nb >= 0; it = next( it ) ) |
| nb--; |
| return it; |
| } |
| |
| int get( Widget *pRoot, Widget *pWidget ) |
| { |
| int nRet = -1; |
| Widget *it; |
| for ( it = pRoot; it != NULL && it != pWidget; it = next( it ) ) |
| nRet++; |
| return nRet; |
| } |
| } |
| |
| //** PropertiesList widget |
| |
| class PropertiesList : public layout::Table |
| { |
| class PropertyEntry |
| { |
| friend class PropertiesList; |
| |
| /* wrapper between the widget and Any */ |
| struct AnyWidget |
| { |
| DECL_LINK( ApplyPropertyHdl, layout::Window* ); |
| DECL_LINK( FlagToggledHdl, layout::CheckBox* ); |
| |
| AnyWidget( Widget *pWidget, rtl::OUString aPropName, Widget::PropertyKind aPropKind ) |
| : mpWidget( pWidget ), maPropName( aPropName ), maPropKind( aPropKind ) |
| { |
| mpFlag = 0; |
| mbBlockFlagCallback = false; |
| bFirstGet = true; |
| } |
| |
| virtual ~AnyWidget() |
| { |
| #if DEBUG_PRINT |
| fprintf(stderr, "~AnyWidget\n"); |
| #endif |
| } |
| |
| void save( uno::Any aValue ) |
| { |
| mpWidget->setProperty( maPropName, maPropKind, aValue ); |
| checkProperty(); |
| } |
| |
| void checkProperty() |
| { |
| bool flag = mpWidget->isPropertyTouched( maPropName, maPropKind ); |
| |
| if ( mpFlag && mpFlag->IsChecked() != (BOOL)flag ) |
| { |
| CheckFlag( flag, true ); |
| } |
| } |
| |
| void CheckFlag( bool bValue, bool bBlockCallback ) |
| { |
| if ( bBlockCallback ) |
| mbBlockFlagCallback = true; |
| mpFlag->Check( bValue ); |
| mbBlockFlagCallback = false; |
| } |
| |
| bool bFirstGet; // HACK |
| rtl::OUString getValue() |
| { |
| // return mpWidget->getOriProperty( maPropName ); |
| rtl::OUString value; |
| if ( bFirstGet ) // king of ugliness |
| value = mpWidget->getProperty( maPropName, maPropKind ); |
| else |
| value = mpWidget->getOriginalProperty( maPropName, maPropKind ); |
| bFirstGet = false; |
| return value; |
| } |
| |
| // FIXME: wrapper should have a base class for this... |
| virtual layout::Window *getWindow() = 0; |
| virtual layout::Container *getContainer() { return NULL; } |
| |
| virtual void load() = 0; |
| virtual void store() = 0; |
| |
| Widget *mpWidget; |
| rtl::OUString maPropName; |
| Widget::PropertyKind maPropKind; |
| layout::CheckBox *mpFlag; |
| bool mbBlockFlagCallback; |
| }; |
| |
| struct AnyEdit : public AnyWidget, layout::HBox |
| { |
| layout::Edit *mpEdit; |
| bool mbMultiLine; |
| layout::PushButton *mpExpand; |
| DECL_LINK( ExpandEditHdl, layout::PushButton* ); |
| |
| // so we can create widgets (like transforming the Edit into a |
| // MultiLineEdit) |
| layout::Window *mpWinParent; |
| |
| AnyEdit( Widget *pWidget, rtl::OUString aPropName, |
| Widget::PropertyKind aPropKind, layout::Window *pWinParent ) |
| : AnyWidget( pWidget, aPropName, aPropKind ), layout::HBox( 0, false ), mpWinParent( pWinParent ) |
| { |
| mpEdit = NULL; |
| mpExpand = new layout::PushButton( pWinParent, WB_TOGGLE ); |
| mpExpand->SetToggleHdl( LINK( this, AnyEdit, ExpandEditHdl ) ); |
| setAsMultiLine( false ); |
| |
| load(); |
| } |
| |
| virtual ~AnyEdit() |
| { |
| delete mpEdit; |
| delete mpExpand; |
| } |
| |
| virtual layout::Window *getWindow() |
| { return NULL; } |
| virtual layout::Container *getContainer() |
| { return this; } |
| |
| void setAsMultiLine( bool bMultiLine ) |
| { |
| Clear(); |
| XubString text; |
| if ( mpEdit ) |
| { |
| text = mpEdit->GetText(); |
| printf("Remove mpEdit and expand\n"); |
| Remove( mpEdit ); |
| Remove( mpExpand ); |
| delete mpEdit; |
| } |
| |
| if ( bMultiLine ) |
| { |
| mpEdit = new layout::Edit( mpWinParent, WB_BORDER ); |
| mpExpand->SetText( String::CreateFromAscii( "-" ) ); |
| } |
| else |
| { |
| mpEdit = new layout::Edit( mpWinParent, WB_BORDER ); |
| mpExpand->SetText( String::CreateFromAscii( "+" ) ); |
| } |
| |
| mpEdit->SetText( text ); |
| mpEdit->SetModifyHdl( LINK( this, AnyEdit, ApplyPropertyHdl ) ); |
| |
| Add( mpEdit, true, true, 0 ); |
| Add( mpExpand, false, true, 0 ); |
| |
| mbMultiLine = bMultiLine; |
| } |
| |
| #if 0 |
| // TODO: make this global... We'll likely need it for export... |
| struct Translate { |
| const char *ori, *dest; |
| }; |
| static rtl::OUString stringReplace( rtl::OUString _str, |
| Translate *trans ) |
| { |
| const sal_Unicode *str = _str.getStr(); |
| rtl::OUStringBuffer buf; |
| int i, j, k; |
| for ( i = 0; i < _str.getLength(); i++ ) |
| { |
| for ( j = 0; trans[ j ].ori; j++ ) |
| { |
| const char *ori = trans[ j ].ori; |
| for ( k = 0; ori[ k ] && i+k < _str.getLength(); k++ ) |
| if ( ori[ k ] != str[ i+k ] ) |
| break; |
| if ( !ori[ k ] ) |
| { |
| // found substring |
| buf.appendAscii( trans[ j ].dest ); |
| i += k; |
| continue; |
| } |
| } |
| buf.append( str[ i ] ); |
| } |
| return buf.makeStringAndClear(); |
| } |
| #endif |
| |
| virtual void load() |
| { |
| #if 0 |
| // replace end of lines by "\\n" strings |
| Translate trans[] = { |
| { "\\", "\\\\" }, { "\n", "\\n" }, { 0, 0 } |
| }; |
| rtl::OUString str = anyToString( getValue() ); |
| str = stringReplace( str, trans ); |
| SetText( str ); |
| #endif |
| mpEdit->SetText( getValue() ); |
| checkProperty(); |
| } |
| |
| virtual void store() |
| { |
| #if 0 |
| // replace "\\n" strings by actual end of lines |
| Translate trans[] = { |
| { "\\\\", "\\" }, { "\\n", "\n" }, |
| { "\\", "" }, { 0, 0 } |
| }; |
| rtl::OUString str = GetText(); |
| str = stringReplace( str, trans ); |
| save( uno::makeAny( str ) ); |
| #endif |
| save( uno::makeAny( (rtl::OUString) mpEdit->GetText() ) ); |
| } |
| }; |
| |
| struct AnyInteger : public AnyWidget, NumericField |
| { |
| AnyInteger( Widget *pWidget, rtl::OUString aPropName, |
| Widget::PropertyKind aPropKind, Window *pWinParent ) |
| : AnyWidget( pWidget, aPropName, aPropKind ), NumericField( pWinParent, WB_SPIN|WB_BORDER ) |
| { |
| load(); |
| SetModifyHdl( LINK( this, AnyInteger, ApplyPropertyHdl ) ); |
| } |
| |
| virtual Window *getWindow() |
| { return this; } |
| |
| virtual void load() |
| { |
| OUString text = getValue(); |
| SetText( text.getStr() ); |
| checkProperty(); |
| } |
| |
| virtual void store() |
| { |
| #if DEBUG_PRINT |
| fprintf(stderr, "store number: %ld\n", rtl::OUString( GetText() ).toInt64()); |
| #endif |
| save( uno::makeAny( rtl::OUString( GetText() ).toInt64() ) ); |
| } |
| }; |
| |
| struct AnyFloat : public AnyInteger |
| { |
| AnyFloat( Widget *pWidget, rtl::OUString aPropName, |
| Widget::PropertyKind aPropKind, Window *pWinParent ) |
| : AnyInteger( pWidget, aPropName, aPropKind, pWinParent ) |
| {} |
| |
| virtual void store() |
| { |
| save( uno::makeAny( rtl::OUString( GetText() ).toDouble() ) ); |
| } |
| }; |
| |
| struct AnyCheckBox : public AnyWidget, layout::CheckBox |
| { |
| AnyCheckBox( Widget *pWidget, rtl::OUString aPropName, |
| Widget::PropertyKind aPropKind, layout::Window *pWinParent ) |
| : AnyWidget( pWidget, aPropName, aPropKind ), layout::CheckBox( pWinParent ) |
| { |
| // adding some whitespaces to make the hit area larger |
| // SetText( String::CreateFromAscii( "" ) ); |
| load(); |
| SetToggleHdl( LINK( this, AnyWidget, ApplyPropertyHdl ) ); |
| } |
| |
| virtual ~AnyCheckBox() |
| { |
| #if DEBUG_PRINT |
| fprintf(stderr, "~AnyCheckBox\n"); |
| #endif |
| } |
| |
| virtual layout::Window *getWindow() |
| { return this; } |
| |
| virtual void load() |
| { |
| #if DEBUG_PRINT |
| fprintf(stderr, "loading boolean value\n"); |
| #endif |
| Check( getValue().toInt64() != 0 ); |
| setLabel(); |
| checkProperty(); |
| } |
| |
| virtual void store() |
| { |
| save( uno::makeAny( IsChecked() ) ); |
| setLabel(); |
| } |
| |
| void setLabel() |
| { |
| SetText( String::CreateFromAscii( IsChecked() ? "true" : "false" ) ); |
| } |
| }; |
| |
| struct AnyListBox : public AnyWidget, layout::ListBox |
| { |
| AnyListBox( Widget *pWidget, rtl::OUString aPropName, |
| Widget::PropertyKind aPropKind, Window *pWinParent ) |
| : AnyWidget( pWidget, aPropName, aPropKind ), layout::ListBox( pWinParent, WB_DROPDOWN ) |
| { |
| SetSelectHdl( LINK( this, AnyWidget, ApplyPropertyHdl ) ); |
| } |
| |
| virtual layout::Window *getWindow() |
| { return this; } |
| |
| virtual void load() |
| { |
| SelectEntryPos( sal::static_int_cast< USHORT >( getValue().toInt32() ) ); |
| checkProperty(); |
| } |
| |
| virtual void store() |
| { |
| save( uno::makeAny( (short) GetSelectEntryPos() ) ); |
| } |
| }; |
| |
| struct AnyAlign : public AnyListBox |
| { |
| AnyAlign( Widget *pWidget, rtl::OUString aPropName, |
| Widget::PropertyKind aPropKind, Window *pWinParent ) |
| : AnyListBox( pWidget, aPropName, aPropKind, pWinParent ) |
| { |
| InsertEntry( XubString::CreateFromAscii( "Left" ) ); |
| InsertEntry( XubString::CreateFromAscii( "Center" ) ); |
| InsertEntry( XubString::CreateFromAscii( "Right" ) ); |
| load(); |
| } |
| }; |
| |
| /* AnyListBox and AnyComboBox different in that a ComboBox allows the user |
| to add other options, operating in strings, instead of constants. |
| (its more like a suggestive AnyEdit) */ |
| struct AnyComboBox : public AnyWidget, layout::ComboBox |
| { |
| AnyComboBox( Widget *pWidget, rtl::OUString aPropName, |
| Widget::PropertyKind aPropKind, Window *pWinParent ) |
| : AnyWidget( pWidget, aPropName, aPropKind ), layout::ComboBox( pWinParent, WB_DROPDOWN ) |
| { |
| SetModifyHdl( LINK( this, AnyComboBox, ApplyPropertyHdl ) ); |
| } |
| |
| virtual layout::Window *getWindow() |
| { return this; } |
| |
| virtual void load() |
| { |
| SetText( getValue() ); |
| checkProperty(); |
| } |
| |
| virtual void store() |
| { |
| save( uno::makeAny( (rtl::OUString) GetText() ) ); |
| } |
| }; |
| |
| struct AnyFontStyle : public AnyComboBox |
| { |
| AnyFontStyle( Widget *pWidget, rtl::OUString aPropName, |
| Widget::PropertyKind aPropKind, Window *pWinParent ) |
| : AnyComboBox( pWidget, aPropName, aPropKind, pWinParent ) |
| { |
| InsertEntry( XubString::CreateFromAscii( "Bold" ) ); |
| InsertEntry( XubString::CreateFromAscii( "Italic" ) ); |
| InsertEntry( XubString::CreateFromAscii( "Bold Italic" ) ); |
| InsertEntry( XubString::CreateFromAscii( "Fett" ) ); |
| load(); |
| } |
| }; |
| |
| layout::FixedText *mpLabel; |
| layout::CheckBox *mpFlag; |
| AnyWidget *mpValue; |
| |
| public: |
| PropertyEntry( layout::Window *pWinParent, AnyWidget *pAnyWidget ) |
| { |
| mpLabel = new layout::FixedText( pWinParent ); |
| { |
| // append ':' to aPropName |
| rtl::OUStringBuffer buf( pAnyWidget->maPropName ); |
| buf.append( sal_Unicode (':') ); |
| mpLabel->SetText( buf.makeStringAndClear() ); |
| } |
| mpValue = pAnyWidget; |
| mpFlag = new layout::CheckBox( pWinParent ); |
| mpFlag->SetToggleHdl( LINK( mpValue, AnyWidget, FlagToggledHdl ) ); |
| mpValue->mpFlag = mpFlag; |
| } |
| |
| ~PropertyEntry() |
| { |
| #if DEBUG_PRINT |
| fprintf(stderr, "REMOVING label, flag and value\n"); |
| #endif |
| delete mpLabel; |
| delete mpFlag; |
| delete mpValue; |
| } |
| |
| // Use this factory rather than the constructor -- check for NULL |
| static PropertyEntry *construct( Widget *pWidget, rtl::OUString aPropName, |
| Widget::PropertyKind aPropKind, sal_uInt16 nType, |
| layout::Window *pWinParent ) |
| { |
| AnyWidget *pAnyWidget; |
| switch (nType) { |
| case uno::TypeClass_STRING: |
| if ( aPropName.compareToAscii( "FontStyleName" ) == 0 ) |
| { |
| pAnyWidget = new AnyFontStyle( pWidget, aPropName, aPropKind, pWinParent ); |
| break; |
| } |
| pAnyWidget = new AnyEdit( pWidget, aPropName, aPropKind, pWinParent ); |
| break; |
| case uno::TypeClass_SHORT: |
| if ( aPropName.compareToAscii( "Align" ) == 0 ) |
| { |
| pAnyWidget = new AnyAlign( pWidget, aPropName, aPropKind, pWinParent ); |
| break; |
| } |
| // otherwise, treat as any other number... |
| case uno::TypeClass_LONG: |
| case uno::TypeClass_UNSIGNED_LONG: |
| pAnyWidget = new AnyInteger( pWidget, aPropName, aPropKind, pWinParent ); |
| break; |
| case uno::TypeClass_FLOAT: |
| case uno::TypeClass_DOUBLE: |
| pAnyWidget = new AnyFloat( pWidget, aPropName, aPropKind, pWinParent ); |
| break; |
| case uno::TypeClass_BOOLEAN: |
| pAnyWidget = new AnyCheckBox( pWidget, aPropName, aPropKind, pWinParent ); |
| break; |
| default: |
| return NULL; |
| } |
| return new PropertyEntry( pWinParent, pAnyWidget ); |
| } |
| }; |
| |
| layout::Window *mpParentWindow; |
| |
| std::list< PropertyEntry* > maPropertiesList; |
| layout::FixedLine *mpSeparator; |
| |
| // some properties are obscure, or simply don't make sense in this |
| // context. Let's just ignore them. |
| // Maybe we could offer them in an expander or something... |
| static bool toIgnore( rtl::OUString prop ) |
| { |
| // binary search -- keep the list sorted alphabetically |
| static char const *toIgnoreList[] = { |
| "DefaultControl", "FocusOnClick", "FontCharWidth", "FontCharset", |
| "FontEmphasisMark", "FontFamily", "FontHeight", "FontKerning", "FontName", |
| "FontOrientation", "FontPitch", "FontRelief", "FontSlant", "FontStrikeout", |
| "FontType", "FontWordLineMode", "HelpText", "HelpURL", "MultiLine", |
| "Printable", "Repeat", "RepeatDelay", "Tabstop" |
| }; |
| |
| #if 0 |
| // checks list sanity -- enable this when you add some entries... |
| for ( unsigned int i = 1; i < sizeof( toIgnoreList )/sizeof( char * ); i++ ) |
| { |
| if ( strcmp(toIgnoreList[i-1], toIgnoreList[i]) >= 0 ) |
| { |
| printf("ignore list not ordered properly: " |
| "'%s' should come before '%s'\n", |
| toIgnoreList[i], toIgnoreList[i-1]); |
| exit(-1); |
| } |
| } |
| #endif |
| |
| int min = 0, max = sizeof( toIgnoreList )/sizeof( char * ) - 1, mid, cmp; |
| do { |
| mid = min + (max - min)/2; |
| cmp = prop.compareToAscii( toIgnoreList[ mid ] ); |
| if ( cmp > 0 ) |
| min = mid+1; |
| else if ( cmp < 0 ) |
| max = mid-1; |
| else |
| return true; |
| } while ( min <= max ); |
| return false; |
| } |
| |
| public: |
| PropertiesList( layout::Dialog *dialog ) |
| : layout::Table( dialog, "properties-box" ) |
| , mpParentWindow( dialog ), mpSeparator( 0 ) |
| { |
| } |
| |
| ~PropertiesList() |
| { |
| clear(); |
| } |
| |
| private: |
| // auxiliary, add properties from the peer to the list |
| void addProperties( Widget *pWidget, Widget::PropertyKind rKind ) |
| { |
| Widget::PropertyIterator it( pWidget, rKind ); |
| while ( it.hasNext() ) |
| { |
| beans::Property prop = it.next(); |
| rtl::OUString name( prop.Name ); |
| if ( toIgnore( name ) ) |
| continue; |
| sal_uInt16 type = static_cast< sal_uInt16 >( prop.Type.getTypeClass() ); |
| |
| PropertyEntry *propEntry = PropertyEntry::construct( |
| pWidget, name, rKind, type, mpParentWindow ); |
| |
| if ( propEntry ) |
| { |
| Add( propEntry->mpLabel, false, false ); |
| |
| // HACK: one of these will return Null... |
| Add( propEntry->mpValue->getWindow(), true, false ); |
| Add( propEntry->mpValue->getContainer(), true, false ); |
| |
| Add( propEntry->mpFlag, false, false ); |
| maPropertiesList.push_back( propEntry ); |
| } |
| } |
| } |
| |
| public: |
| void selectedWidget( Widget *pWidget ) |
| { |
| clear(); |
| |
| if ( !pWidget ) |
| return; |
| |
| addProperties( pWidget, Widget::CONTAINER_PROPERTY ); |
| |
| mpSeparator = new layout::FixedLine( mpParentWindow ); |
| // TODO: we may want to have to separate list widgets here... |
| Add( mpSeparator, false, false, 3, 1 ); |
| |
| addProperties( pWidget, Widget::WINDOW_PROPERTY ); |
| |
| ShowAll( true ); |
| } |
| |
| void clear() |
| { |
| ///FIXME: crash |
| Container::Clear(); |
| |
| for ( std::list< PropertyEntry* >::iterator it = maPropertiesList.begin(); |
| it != maPropertiesList.end(); it++) |
| delete *it; |
| maPropertiesList.clear(); |
| |
| delete mpSeparator; |
| mpSeparator = NULL; |
| } |
| }; |
| |
| IMPL_LINK( PropertiesList::PropertyEntry::AnyWidget, ApplyPropertyHdl, layout::Window *, pWin ) |
| { |
| (void) pWin; |
| store(); |
| return 0; |
| } |
| |
| IMPL_LINK( PropertiesList::PropertyEntry::AnyWidget, FlagToggledHdl, layout::CheckBox *, pCheck ) |
| { |
| #if DEBUG_PRINT |
| fprintf(stderr, "Property flag pressed -- is: %d\n", pCheck->IsChecked()); |
| #endif |
| if ( !mbBlockFlagCallback ) |
| { |
| bool checked = pCheck->IsChecked(); |
| if ( !checked ) // revert |
| { |
| #if DEBUG_PRINT |
| fprintf(stderr, "revert\n"); |
| #endif |
| load(); |
| } |
| else |
| { |
| #if DEBUG_PRINT |
| fprintf(stderr, "user can't dirty the flag!\n"); |
| #endif |
| // User can't flag the property as dirty |
| // Actually, we may want to allow the designer to force a property to be stored. |
| // Could be useful when the default value of some new property wasn't yet decided... |
| CheckFlag( false, true ); |
| } |
| } |
| #if DEBUG_PRINT |
| else |
| fprintf(stderr, "Property flag pressed -- BLOCKED\n"); |
| #endif |
| return 0; |
| } |
| |
| IMPL_LINK( PropertiesList::PropertyEntry::AnyEdit, ExpandEditHdl, layout::PushButton *, pBtn ) |
| { |
| setAsMultiLine( pBtn->IsChecked() ); |
| return 0; |
| } |
| |
| //** SortListBox auxiliary widget |
| |
| class SortListBox |
| { // For a manual sort ListBox; asks for a ListBox and Up/Down/Remove |
| // buttons to wrap |
| DECL_LINK( ItemSelectedHdl, layout::ListBox* ); |
| DECL_LINK( UpPressedHdl, layout::Button* ); |
| DECL_LINK( DownPressedHdl, layout::Button* ); |
| DECL_LINK( RemovePressedHdl, layout::Button* ); |
| layout::PushButton *mpUpButton, *mpDownButton, *mpRemoveButton; |
| |
| protected: |
| layout::ListBox *mpListBox; |
| |
| virtual void upPressed( USHORT nPos ) |
| { |
| XubString str = mpListBox->GetSelectEntry(); |
| mpListBox->RemoveEntry( nPos ); |
| nPos = mpListBox->InsertEntry( str, nPos-1 ); |
| mpListBox->SelectEntryPos( nPos ); |
| } |
| |
| virtual void downPressed( USHORT nPos ) |
| { |
| XubString str = mpListBox->GetSelectEntry(); |
| mpListBox->RemoveEntry( nPos ); |
| nPos = mpListBox->InsertEntry( str, nPos+1 ); |
| mpListBox->SelectEntryPos( nPos ); |
| } |
| |
| virtual void removePressed( USHORT nPos ) |
| { |
| mpListBox->RemoveEntry( nPos ); |
| } |
| |
| virtual void itemSelected( USHORT nPos ) |
| { |
| // if we had some XLayoutContainer::canAdd() or maxChildren() function |
| // we could make a function to check if we can move selected and enable/ |
| // /disable the move buttons as appropriate |
| |
| if ( nPos == LISTBOX_ENTRY_NOTFOUND ) |
| { |
| mpUpButton->Disable(); |
| mpDownButton->Disable(); |
| mpRemoveButton->Disable(); |
| } |
| else |
| { |
| mpUpButton->Enable(); |
| mpDownButton->Enable(); |
| mpRemoveButton->Enable(); |
| } |
| } |
| |
| public: |
| SortListBox( layout::ListBox *pListBox, layout::PushButton *pUpButton, layout::PushButton *pDownButton, |
| layout::PushButton *pRemoveButton ) |
| : mpUpButton( pUpButton), mpDownButton( pDownButton), mpRemoveButton( pRemoveButton ), |
| mpListBox( pListBox ) |
| { |
| mpListBox->SetSelectHdl( LINK( this, SortListBox, ItemSelectedHdl ) ); |
| |
| mpUpButton->SetModeImage( layout::Image ( "res/commandimagelist/lc_moveup.png" ) ); |
| mpUpButton->SetImageAlign( IMAGEALIGN_LEFT ); |
| mpUpButton->SetClickHdl( LINK( this, SortListBox, UpPressedHdl ) ); |
| |
| mpDownButton->SetModeImage( layout::Image ( "res/commandimagelist/lc_movedown.png" ) ); |
| mpDownButton->SetImageAlign( IMAGEALIGN_LEFT ); |
| mpDownButton->SetClickHdl( LINK( this, SortListBox, DownPressedHdl ) ); |
| |
| // "res/commandimagelist/lch_delete.png", "res/commandimagelist/lc_delete.png" |
| mpRemoveButton->SetModeImage( layout::Image ( "res/commandimagelist/sc_closedoc.png" ) ); |
| mpRemoveButton->SetImageAlign( IMAGEALIGN_LEFT ); |
| mpRemoveButton->SetClickHdl( LINK( this, SortListBox, RemovePressedHdl ) ); |
| |
| // fire an un-select event |
| itemSelected( LISTBOX_ENTRY_NOTFOUND ); |
| } |
| |
| virtual ~SortListBox(); |
| }; |
| |
| SortListBox::~SortListBox() |
| { |
| delete mpListBox; |
| delete mpUpButton; |
| delete mpDownButton; |
| delete mpRemoveButton; |
| } |
| |
| IMPL_LINK( SortListBox, UpPressedHdl, layout::Button *, pBtn ) |
| { |
| (void) pBtn; |
| USHORT pos = mpListBox->GetSelectEntryPos(); |
| if ( pos > 0 && pos != LISTBOX_ENTRY_NOTFOUND ) |
| upPressed( pos ); |
| return 0; |
| } |
| |
| IMPL_LINK( SortListBox, DownPressedHdl, layout::Button *, pBtn ) |
| { |
| (void) pBtn; |
| USHORT pos = mpListBox->GetSelectEntryPos(); |
| if ( pos < mpListBox->GetEntryCount() && pos != LISTBOX_ENTRY_NOTFOUND ) |
| downPressed( pos ); |
| return 0; |
| } |
| |
| IMPL_LINK( SortListBox, RemovePressedHdl, layout::Button *, pBtn ) |
| { |
| (void) pBtn; |
| USHORT pos = mpListBox->GetSelectEntryPos(); |
| if ( pos != LISTBOX_ENTRY_NOTFOUND ) |
| removePressed( pos ); |
| return 0; |
| } |
| |
| IMPL_LINK( SortListBox, ItemSelectedHdl, layout::ListBox *, pList ) |
| { |
| (void) pList; |
| USHORT pos = mpListBox->GetSelectEntryPos(); |
| itemSelected( pos ); |
| return 0; |
| } |
| |
| //** LayoutTree widget |
| |
| class LayoutTree : public SortListBox |
| { |
| public: |
| struct Listener |
| { |
| virtual void widgetSelected( Widget *pWidget ) = 0; |
| }; |
| |
| private: |
| Listener *mpListener; |
| |
| public: |
| Widget *mpRootWidget; |
| |
| LayoutTree( layout::Dialog *dialog ) |
| : SortListBox( new layout::ListBox( dialog, "layout-tree" ), |
| new layout::PushButton( dialog, "layout-up-button" ), |
| new layout::PushButton( dialog, "layout-down-button" ), |
| new layout::PushButton( dialog, "layout-remove-button" ) ) |
| { |
| layout::PeerHandle handle = dialog->GetPeerHandle( "preview-box" ); |
| uno::Reference< awt::XLayoutConstrains > xWidget( handle, uno::UNO_QUERY ); |
| mpRootWidget = new Widget( xWidget, "root" ); |
| } |
| |
| virtual ~LayoutTree(); |
| |
| Widget *getWidget( int nPos ) |
| { |
| if ( nPos != LISTBOX_ENTRY_NOTFOUND ) |
| return FlatLayout::get( mpRootWidget, nPos ); |
| return NULL; |
| } |
| |
| Widget *getSelectedWidget() |
| { |
| Widget *pWidget = getWidget( mpListBox->GetSelectEntryPos() ); |
| if ( !pWidget ) // return root, if none selected |
| pWidget = mpRootWidget; |
| return pWidget; |
| } |
| |
| void selectWidget( Widget *pWidget ) |
| { |
| int pos = FlatLayout::get( mpRootWidget, pWidget ); |
| if ( pos == -1 ) |
| // if asked to select hidden root, select visible root |
| pos = 0; |
| mpListBox->SelectEntryPos( sal::static_int_cast< USHORT >( pos ) ); |
| } |
| |
| void rebuild() |
| { |
| struct inner |
| { |
| // pads a string with whitespaces |
| static rtl::OUString padString( rtl::OUString name, int depth ) |
| { |
| rtl::OStringBuffer aBuf( depth * 4 + name.getLength() + 2 ); |
| for (int i = 0; i < depth; i++) |
| aBuf.append( " " ); |
| aBuf.append( rtl::OUStringToOString( name, RTL_TEXTENCODING_ASCII_US ) ); |
| return rtl::OUString( aBuf.getStr(), aBuf.getLength(), |
| RTL_TEXTENCODING_UTF8 ); |
| } |
| }; |
| |
| mpListBox->Clear(); |
| for ( Widget *i = FlatLayout::next( mpRootWidget ); i; i = FlatLayout::next( i ) ) |
| mpListBox->InsertEntry( inner::padString( i->getLabel(), i->getDepth()-1 ) ); |
| |
| // any selection, no longer is. ListBox doesn't fire the event on this case; |
| // force it. |
| itemSelected( LISTBOX_ENTRY_NOTFOUND ); |
| } |
| |
| void setListener( Listener *pListener ) |
| { mpListener = pListener; } |
| |
| // print in XML format... |
| |
| static rtl::OUString toXMLNaming (const rtl::OUString &string) |
| { |
| rtl::OUStringBuffer buffer (string.getLength()); |
| sal_Unicode *str = string.pData->buffer; |
| for (int i = 0; i < string.getLength(); i++) { |
| if ( str[i] >= 'A' && str[i] <= 'Z' ) |
| { |
| if ( i > 0 ) |
| buffer.append ((sal_Unicode) '-'); |
| buffer.append ((sal_Unicode) (str[i] - 'A' + 'a')); |
| } |
| else |
| buffer.append ((sal_Unicode) str[i]); |
| } |
| |
| return buffer.makeStringAndClear(); |
| } |
| |
| void print() |
| { |
| printf("\t\tExport:\n"); |
| printf("<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" |
| "<dialog xmlns=\"http://openoffice.org/2007/layout\"\n" |
| " xmlns:cnt=\"http://openoffice.org/2007/layout/container\"\n" |
| " id=\"dialog\" title=\"Unnamed\" sizeable=\"true\" >\n"); |
| |
| for ( Widget *i = FlatLayout::next( mpRootWidget ); i; i = FlatLayout::next( i ) ) |
| { |
| for ( int d = i->getDepth(); d > 0; d-- ) |
| printf(" "); |
| printf("<%s ", OUSTRING_CSTR( i->getUnoName() ) ); |
| |
| for ( int kind = 0; kind < 2; kind++ ) |
| { |
| Widget::PropertyKind wKind = kind == 0 ? Widget::WINDOW_PROPERTY |
| : Widget::CONTAINER_PROPERTY; |
| Widget::PropertyIterator it( i, wKind ); |
| while ( it.hasNext() ) |
| { |
| beans::Property prop = it.next(); |
| if ( !i->isPropertyTouched( prop.Name, wKind ) ) |
| continue; |
| |
| rtl::OUString value = i->getProperty( prop.Name, wKind ); |
| if ( prop.Type.getTypeClass() == uno::TypeClass_BOOLEAN ) |
| { |
| if ( value.compareToAscii( "0" ) ) |
| value = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("false") ); |
| else |
| value = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM("true") ); |
| } |
| |
| if ( value.getLength() > 0 ) |
| printf("%s%s=\"%s\" ", |
| kind == 0 ? "" : "cnt:", |
| OUSTRING_CSTR( toXMLNaming( prop.Name ) ), OUSTRING_CSTR( value ) |
| ); |
| |
| } |
| } |
| printf("/>\n"); |
| } |
| printf("</dialog>\n"); |
| } |
| |
| protected: |
| virtual void upPressed( USHORT nPos ) |
| { |
| Widget *pWidget = getWidget( nPos ); |
| if ( FlatLayout::moveWidget( pWidget, true ) ) |
| rebuild(); |
| selectWidget( pWidget ); |
| } |
| |
| virtual void downPressed( USHORT nPos ) |
| { |
| Widget *pWidget = getWidget( nPos ); |
| if ( FlatLayout::moveWidget( pWidget, false ) ) |
| rebuild(); |
| selectWidget( pWidget ); |
| } |
| |
| virtual void removePressed( USHORT nPos ) |
| { |
| Widget *pWidget = getWidget( nPos ); |
| if ( pWidget ) |
| { |
| pWidget->up()->removeChild( pWidget ); |
| delete pWidget; |
| rebuild(); |
| } |
| } |
| |
| virtual void itemSelected( USHORT nPos ) |
| { |
| mpListener->widgetSelected( getWidget( nPos ) ); |
| SortListBox::itemSelected( nPos ); |
| } |
| }; |
| |
| LayoutTree::~LayoutTree() |
| { |
| delete mpRootWidget; |
| } |
| |
| //** EditorImpl |
| |
| class EditorImpl : public LayoutTree::Listener |
| { |
| void createWidget( const char *unoName ); |
| |
| PropertiesList *mpPropertiesList; |
| LayoutTree *mpLayoutTree; |
| |
| layout::PushButton *pImportButton, *pExportButton; |
| #ifdef FILEDLG |
| FileDialog *pImportDialog; |
| #endif |
| DECL_LINK( ImportButtonHdl, layout::PushButton* ); |
| DECL_LINK( ExportButtonHdl, layout::PushButton* ); |
| #ifdef FILEDLG |
| DECL_LINK( ImportDialogHdl, FileDialog* ); |
| #endif |
| |
| // framework stuff |
| uno::Reference< lang::XMultiServiceFactory > mxFactory; |
| uno::Reference< awt::XToolkit > mxToolkit; |
| uno::Reference< awt::XWindow > mxToplevel; |
| |
| virtual void widgetSelected( Widget *pWidget ); |
| DECL_LINK( CreateWidgetHdl, layout::Button* ); |
| |
| std::list< layout::PushButton *> maCreateButtons; |
| |
| public: |
| |
| EditorImpl( layout::Dialog *dialog, |
| // we should probable open this channel (or whatever its called) ourselves |
| uno::Reference< lang::XMultiServiceFactory > xMSF ); |
| virtual ~EditorImpl(); |
| |
| void loadFile( const rtl::OUString &aTestFile ); |
| }; |
| |
| EditorImpl::EditorImpl( layout::Dialog *dialog, |
| uno::Reference< lang::XMultiServiceFactory > xFactory ) |
| : mxFactory( xFactory ) |
| , mxToplevel( dialog->GetPeerHandle( "dialog" ), uno::UNO_QUERY ) |
| // FIXME: any of these should work |
| //dialog->getContext()->getRoot(), uno::UNO_QUERY ) |
| // dialog->GetPeer(), uno::UNO_QUERY ) |
| { |
| #if DEBUG_PRINT |
| fprintf (stderr, "EditorImpl()\n"); |
| #endif |
| // framework |
| mxToolkit = uno::Reference< awt::XToolkit >( |
| mxFactory->createInstance( |
| rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "com.sun.star.awt.Toolkit" ) ) ), |
| uno::UNO_QUERY ); |
| OSL_ASSERT( mxToolkit.is() ); |
| |
| // custom widgets |
| #if DEBUG_PRINT |
| fprintf (stderr, "custom widgets\n"); |
| #endif |
| mpPropertiesList = new PropertiesList( dialog ); |
| |
| mpLayoutTree = new LayoutTree( dialog ); |
| mpLayoutTree->setListener( this ); |
| |
| /* if ( xImport.is() ) |
| mpLayoutTree->getWidget( -1 )->addChild( new Widget( xImport, "import" ) );*/ |
| |
| // create buttons |
| layout::Container aWidgets( dialog, "create-widget" ); |
| layout::Container aContainers( dialog, "create-container" ); |
| for ( int i = 0; i < WIDGETS_SPECS_LEN; i++ ) |
| { |
| layout::PushButton *pBtn = new layout::PushButton( (layout::Window *) dialog ); |
| pBtn->SetText( rtl::OUString::createFromAscii( WIDGETS_SPECS[ i ].pLabel ) ); |
| pBtn->SetClickHdl( LINK( this, EditorImpl, CreateWidgetHdl ) ); |
| if ( WIDGETS_SPECS[ i ].pIconName != NULL ) |
| { |
| rtl::OString aPath ("res/commandimagelist/"); |
| aPath += WIDGETS_SPECS[ i ].pIconName; |
| layout::Image aImg( aPath ); |
| pBtn->SetModeImage( aImg ); |
| pBtn->SetImageAlign( IMAGEALIGN_LEFT ); |
| } |
| pBtn->Show(); |
| maCreateButtons.push_back( pBtn ); |
| layout::Container *pBox = WIDGETS_SPECS[ i ].bIsContainer ? &aContainers : &aWidgets; |
| pBox->Add( pBtn ); |
| } |
| |
| #ifdef FILEDLG |
| fprintf(stderr,"creating file dialog\n"); |
| pImportDialog = new FileDialog( NULL/*(layout::Window *) dialog*/, 0 ); |
| fprintf(stderr,"connecting it\n"); |
| pImportDialog->SetFileSelectHdl( LINK( this, EditorImpl, ImportDialogHdl ) ); |
| fprintf(stderr,"done file dialog\n"); |
| #endif |
| |
| /* pImportButton = new layout::PushButton( dialog, "import-button" ); |
| pImportButton->SetClickHdl( LINK( this, EditorImpl, ImportButtonHdl ) );*/ |
| pExportButton = new layout::PushButton( dialog, "export-button" ); |
| pExportButton->SetClickHdl( LINK( this, EditorImpl, ExportButtonHdl ) ); |
| } |
| |
| EditorImpl::~EditorImpl() |
| { |
| delete mpPropertiesList; |
| delete mpLayoutTree; |
| for ( std::list< layout::PushButton * >::const_iterator i = maCreateButtons.begin(); |
| i != maCreateButtons.end(); i++) |
| delete *i; |
| delete pImportButton; |
| delete pExportButton; |
| #ifdef FILEDLG |
| delete pImportDialog; |
| #endif |
| } |
| |
| void EditorImpl::loadFile( const rtl::OUString &aTestFile ) |
| { |
| fprintf( stderr, "TEST: layout instance\n" ); |
| uno::Reference< awt::XLayoutRoot > xRoot |
| ( new EditorRoot( mxFactory, mpLayoutTree->mpRootWidget ) ); |
| |
| /* |
| mxMSF->createInstance |
| ( ::rtl::OUString::createFromAscii( "com.sun.star.awt.Layout" ) ), |
| uno::UNO_QUERY ); |
| */ |
| if ( !xRoot.is() ) |
| { |
| throw uno::RuntimeException( |
| OUString( RTL_CONSTASCII_USTRINGPARAM("could not create awt Layout component!") ), |
| uno::Reference< uno::XInterface >() ); |
| } |
| |
| #if DEBUG_PRINT |
| fprintf( stderr, "TEST: initing root\n" ); |
| #endif |
| |
| uno::Reference< lang::XInitialization > xInit( xRoot, uno::UNO_QUERY ); |
| if ( !xInit.is() ) |
| { |
| throw uno::RuntimeException( |
| OUString( RTL_CONSTASCII_USTRINGPARAM("Layout has no XInitialization!") ), |
| uno::Reference< uno::XInterface >() ); |
| } |
| |
| #if DEBUG_PRINT |
| fprintf( stderr, "TEST: running parser\n" ); |
| #endif |
| uno::Sequence< uno::Any > aParams( 1 ); |
| aParams[0] <<= aTestFile; |
| #if DEBUG_PRINT |
| fprintf( stderr, "TEST: do it\n" ); |
| #endif |
| xInit->initialize( aParams ); |
| #if DEBUG_PRINT |
| fprintf( stderr, "TEST: file loaded\n" ); |
| #endif |
| |
| mpLayoutTree->rebuild(); |
| } |
| |
| void EditorImpl::createWidget( const char *name ) |
| { |
| Widget *pWidget = mpLayoutTree->getSelectedWidget(); |
| |
| Widget *pChild = new Widget( rtl::OUString(), mxToolkit, uno::Reference< awt::XLayoutContainer >( mxToplevel, uno::UNO_QUERY ), rtl::OUString::createFromAscii( name ), awt::WindowAttribute::SHOW ); |
| if ( !pWidget->addChild( pChild ) ) |
| { |
| delete pChild; |
| // we may want to popup an error message |
| } |
| else |
| { |
| mpLayoutTree->rebuild(); |
| mpLayoutTree->selectWidget( pWidget ); |
| } |
| } |
| |
| void EditorImpl::widgetSelected( Widget *pWidget ) |
| { |
| // we know can't add widget to a non-container, so let's disable the create |
| // buttons then. Would be nice to have a method to check if a container is |
| // full as well... |
| if ( !pWidget || pWidget->isContainer() ) |
| { |
| for ( std::list< layout::PushButton *>::const_iterator it = maCreateButtons.begin(); |
| it != maCreateButtons.end(); it++) |
| (*it)->Enable(); |
| } |
| else |
| { |
| for ( std::list< layout::PushButton *>::const_iterator it = maCreateButtons.begin(); |
| it != maCreateButtons.end(); it++) |
| (*it)->Disable(); |
| } |
| |
| mpPropertiesList->selectedWidget( pWidget ); |
| } |
| |
| IMPL_LINK( EditorImpl, CreateWidgetHdl, layout::Button *, pBtn ) |
| { |
| int i = 0; |
| for ( std::list< layout::PushButton *>::const_iterator it = maCreateButtons.begin(); |
| it != maCreateButtons.end(); it++, i++ ) |
| { |
| if ( pBtn == *it ) |
| break; |
| } |
| OSL_ASSERT( i < WIDGETS_SPECS_LEN ); |
| createWidget( WIDGETS_SPECS[i].pName ); |
| return 0; |
| } |
| |
| IMPL_LINK( EditorImpl, ImportButtonHdl, layout::PushButton *, pBtn ) |
| { |
| (void) pBtn; |
| #if DEBUG_PRINT |
| fprintf(stderr, "IMPORT!\n"); |
| #endif |
| #ifdef FILEDLG |
| pImportDialog->Execute(); |
| #endif |
| |
| return 0; |
| } |
| |
| #ifdef FILEDLG |
| IMPL_LINK( EditorImpl, ImportDialogHdl, FileDialog *, pDialog ) |
| { |
| UniString path = pDialog->GetPath(); |
| //fprintf(stderr, "Executing import dialog!\n"); |
| |
| #if DEBUG_PRINT |
| fprintf(stderr, "got import file: %s\n",rtl::OUStringToOString( path, RTL_TEXTENCODING_ASCII_US ).getStr() ); |
| #endif |
| |
| return 0; |
| } |
| #endif |
| |
| IMPL_LINK( EditorImpl, ExportButtonHdl, layout::PushButton *, pBtn ) |
| { |
| (void) pBtn; |
| mpLayoutTree->print(); |
| return 0; |
| } |
| |
| //** Editor, the Dialog |
| |
| Editor::Editor( uno::Reference< lang::XMultiServiceFactory > xFactory, |
| rtl::OUString aFile ) |
| : layout::Dialog( (Window*) (NULL), "editor.xml", "dialog" ) |
| , mpImpl( new EditorImpl( this, xFactory ) ) |
| { |
| if ( aFile.getLength() ) |
| mpImpl->loadFile( aFile ); |
| |
| // parent: |
| FreeResource(); |
| } |
| |
| Editor::~Editor() |
| { |
| delete mpImpl; |
| } |
