Changeset 2227

Show
Ignore:
Timestamp:
08/24/08 22:26:58 (3 months ago)
Author:
hlamer
Message:

Started to divide XUPItem class onto two classes

Location:
v2/branches/dev
Files:
2 added
26 modified

Legend:

Unmodified
Added
Removed
  • v2/branches/dev/monkey/sdk/xupmanager.h

    r1727 r2227  
    11#include "../src/xupmanager/XUPIO.h" 
    22#include "../src/xupmanager/XUPItem.h" 
     3#include "../src/xupmanager/XUPProjectItem.h" 
    34#include "../src/xupmanager/ProjectItemModel.h" 
    45#include "../src/xupmanager/ScopedProjectItemModel.h" 
  • v2/branches/dev/monkey/src/consolemanager/pCommand.h

    r2216 r2227  
    4040#include <QStringList> 
    4141 
    42 class XUPItem; 
     42class XUPProjectItem; 
    4343 
    4444/*! 
     
    8989        bool tryAllParsers() const { return mTryAllParsers; } 
    9090        QVariant userData() const { return mUserData; } 
    91         XUPItem* project() const { return mProject; } 
     91        XUPProjectItem* project() const { return mProject; } 
    9292 
    9393        void setText( const QString& s ) { mText = s; } 
     
    101101        void setTryAllParsers( bool b ) { mTryAllParsers = b; } 
    102102        void setUserData( const QVariant& data ) { mUserData = data; } 
    103         void setProject( XUPItem* project ) { mProject = project; } 
     103        void setProject( XUPProjectItem* project ) { mProject = project; } 
    104104         
    105105        QString toString() const 
     
    130130        bool mTryAllParsers;            /**< Try to use all availible parsers after parsers from list */ 
    131131        QVariant mUserData;                     /**< Ask PasNox, hot to use it */ 
    132         XUPItem* mProject;                      /**< Project, for which command is executing */ 
     132        XUPProjectItem* mProject;                       /**< Project, for which command is executing */ 
    133133}; 
    134134 
  • v2/branches/dev/monkey/src/pluginsmanager/XUPPlugin.h

    r2142 r2227  
    44#include "BasePlugin.h" 
    55 
    6 class XUPItem; 
     6class XUPProjectItem; 
    77 
    88class Q_MONKEY_EXPORT XUPPlugin : public BasePlugin 
    99{ 
    1010public: 
    11         virtual bool editProject( XUPItem* project ) = 0; 
     11        virtual bool editProject( XUPProjectItem* project ) = 0; 
    1212}; 
    1313 
  • v2/branches/dev/monkey/src/templatesmanager/pTemplatesManager.cpp

    r2178 r2227  
    3838#include "../workspace/pFileManager.h" 
    3939#include "../xupmanager/XUPItem.h" 
     40#include "../xupmanager/XUPProjectItem.h" 
    4041#include "../coremanager/MonkeyCore.h" 
    4142#include "../settingsmanager/Settings.h" 
  • v2/branches/dev/monkey/src/templatesmanager/ui/UITemplatesWizard.cpp

    r1900 r2227  
    3636#include "../../xupmanager/ScopedProjectItemModel.h" 
    3737#include "../../xupmanager/XUPItem.h" 
     38#include "../../xupmanager/XUPProjectItem.h" 
    3839#include "../../xupmanager/ui/UIXUPManager.h" 
    3940#include "../../variablesmanager/VariablesManager.h" 
  • v2/branches/dev/monkey/src/workspace/pFileManager.cpp

    r1729 r2227  
    3030#include "pWorkspace.h" 
    3131#include "../xupmanager/ui/UIXUPManager.h" 
    32 #include "../xupmanager/XUPItem.h" 
     32#include "../xupmanager/XUPProjectItem.h" 
    3333#include "pAbstractChild.h" 
    3434#include "../coremanager/MonkeyCore.h" 
     
    4242        connect( MonkeyCore::workspace(), SIGNAL( currentFileChanged( pAbstractChild*, const QString& ) ), this, SIGNAL( currentFileChanged( pAbstractChild*, const QString& ) ) ); 
    4343        // projects 
    44         connect( MonkeyCore::projectsManager(), SIGNAL( projectAboutToClose( XUPItem* ) ), this, SIGNAL( aboutToClose( XUPItem* ) ) ); 
    45         connect( MonkeyCore::projectsManager(), SIGNAL( projectClosed( XUPItem* ) ), this, SIGNAL( closed( XUPItem* ) ) ); 
    46         connect( MonkeyCore::projectsManager(), SIGNAL( projectModifiedChanged( XUPItem*, bool ) ), this, SIGNAL( modifiedChanged( XUPItem*, bool ) ) ); 
    47         connect( MonkeyCore::projectsManager(), SIGNAL( currentProjectChanged( XUPItem* ) ), this, SIGNAL( currentChanged( XUPItem* ) ) ); 
    48         connect( MonkeyCore::projectsManager(), SIGNAL( projectOpen( XUPItem* ) ), this, SIGNAL( opened( XUPItem* ) ) ); 
     44        connect( MonkeyCore::projectsManager(), SIGNAL( projectAboutToClose( XUPProjectItem* ) ), this, SIGNAL( aboutToClose( XUPProjectItem* ) ) ); 
     45        connect( MonkeyCore::projectsManager(), SIGNAL( projectClosed( XUPProjectItem* ) ), this, SIGNAL( closed( XUPProjectItem* ) ) ); 
     46        connect( MonkeyCore::projectsManager(), SIGNAL( projectModifiedChanged( XUPProjectItem*, bool ) ), this, SIGNAL( modifiedChanged( XUPProjectItem*, bool ) ) ); 
     47        connect( MonkeyCore::projectsManager(), SIGNAL( currentProjectChanged( XUPProjectItem* ) ), this, SIGNAL( currentChanged( XUPProjectItem* ) ) ); 
     48        connect( MonkeyCore::projectsManager(), SIGNAL( projectOpen( XUPProjectItem* ) ), this, SIGNAL( opened( XUPProjectItem* ) ) ); 
    4949} 
    5050 
    51 XUPItem* pFileManager::currentProject() const 
     51XUPProjectItem* pFileManager::currentProject() const 
    5252{ return MonkeyCore::projectsManager()->currentProject(); } 
    5353 
  • v2/branches/dev/monkey/src/workspace/pFileManager.h

    r1729 r2227  
    3636 
    3737class pAbstractChild; 
     38class XUPProjectItem; 
    3839class XUPItem; 
    3940 
     
    4546 
    4647public: 
    47         XUPItem* currentProject() const; 
     48        XUPProjectItem* currentProject() const; 
    4849        QString currentProjectFile() const; 
    4950        QString currentProjectPath() const; 
     
    7273        void currentFileChanged( pAbstractChild*, const QString& ); 
    7374        // projects 
    74         void aboutToClose( XUPItem* ); 
    75         void closed( XUPItem* ); 
    76         void modifiedChanged( XUPItem*, bool ); 
    77         void currentChanged( XUPItem* ); 
    78         void opened( XUPItem* ); 
     75        void aboutToClose( XUPProjectItem* ); 
     76        void closed( XUPProjectItem* ); 
     77        void modifiedChanged( XUPProjectItem*, bool ); 
     78        void currentChanged( XUPProjectItem* ); 
     79        void opened( XUPProjectItem* ); 
    7980}; 
    8081 
  • v2/branches/dev/monkey/src/workspace/pWorkspace.cpp

    r2141 r2227  
    4747#include "../templatesmanager/pTemplatesManager.h" 
    4848#include "../xupmanager/ui/UIXUPManager.h" 
    49 #include "../xupmanager/XUPItem.h" 
     49#include "../xupmanager/XUPProjectItem.h" 
    5050#include "../pluginsmanager/PluginsManager.h" 
    5151#include "../coremanager/MonkeyCore.h" 
     
    9393        connect( listWidget(), SIGNAL( customContextMenuRequested( const QPoint& ) ), this, SLOT( internal_listWidget_customContextMenuRequested( const QPoint& ) ) ); 
    9494        connect( MonkeyCore::projectsManager(), SIGNAL( projectCustomContextMenuRequested( const QPoint& ) ), this, SLOT( internal_projectsManager_customContextMenuRequested( const QPoint& ) ) ); 
    95         connect( MonkeyCore::projectsManager(), SIGNAL( currentProjectChanged( XUPItem*, XUPItem* ) ), this, SLOT( internal_currentProjectChanged( XUPItem*, XUPItem* ) ) ); 
     95        connect( MonkeyCore::projectsManager(), SIGNAL( currentProjectChanged( XUPProjectItem*, XUPProjectItem* ) ), this, SLOT( internal_currentProjectChanged( XUPProjectItem*, XUPProjectItem* ) ) ); 
    9696        connect( MonkeyCore::projectsManager(), SIGNAL( projectInstallCommandRequested( const pCommand&, const QString& ) ), this, SLOT( internal_projectInstallCommandRequested( const pCommand&, const QString& ) ) ); 
    9797        connect( MonkeyCore::projectsManager(), SIGNAL( projectUninstallCommandRequested( const pCommand&, const QString& ) ), this, SLOT( internal_projectUninstallCommandRequested( const pCommand&, const QString& ) ) ); 
     
    415415} 
    416416 
    417 void pWorkspace::internal_currentProjectChanged( XUPItem* currentProject, XUPItem* previousProject ) 
     417void pWorkspace::internal_currentProjectChanged( XUPProjectItem* currentProject, XUPProjectItem* previousProject ) 
    418418{ 
    419419        // uninstall old commands 
  • v2/branches/dev/monkey/src/workspace/pWorkspace.h

    r1985 r2227  
    3636class pAbstractChild; 
    3737class QMainWindow; 
    38 class XUPItem; 
     38class XUPProjectItem; 
    3939class QFileSystemWatcher; 
    4040 
     
    7979        void internal_listWidget_customContextMenuRequested( const QPoint& ); 
    8080        void internal_projectsManager_customContextMenuRequested( const QPoint& pos ); 
    81         void internal_currentProjectChanged( XUPItem* currentProject, XUPItem* previousProject ); 
     81        void internal_currentProjectChanged( XUPProjectItem* currentProject, XUPProjectItem* previousProject ); 
    8282        void internal_projectInstallCommandRequested( const pCommand& cmd, const QString& mnu ); 
    8383        void internal_projectUninstallCommandRequested( const pCommand& cmd, const QString& mnu ); 
  • v2/branches/dev/monkey/src/xupmanager/FilteredProjectItemModel.h

    r1933 r2227  
    88 
    99#include "XUPItem.h" 
     10#include "XUPProjectItem.h" 
    1011 
    1112class ProjectItemModel; 
     
    3839        { return mItem; } 
    3940         
    40         XUPItem* project() const 
     41        XUPProjectItem* project() const 
    4142        { 
    4243                if ( mItem->isProject() ) 
    43                         return mItem; 
     44                        return dynamic_cast<XUPProjectItem*> (mItem); 
    4445                else if ( mItem->isType( "value" ) ) 
    45                         return mItem->project(); 
     46                        return dynamic_cast<XUPProjectItem*> (mItem->project()); 
    4647                /* 
    4748                else if ( mItem->isType( "folder" ) ) 
  • v2/branches/dev/monkey/src/xupmanager/ProjectItemModel.cpp

    r1729 r2227  
    11#include "ProjectItemModel.h" 
    22#include "XUPItem.h" 
     3#include "XUPProjectItem.h" 
    34#include "FilteredProjectItemModel.h" 
    45#include "ScopedProjectItemModel.h" 
     
    2021{ QStandardItemModel::appendRow( it ); } 
    2122 
    22 QList<XUPItem*> ProjectItemModel::topLevelProjects( int c ) const 
     23QList<XUPProjectItem*> ProjectItemModel::topLevelProjects( int c ) const 
    2324{ 
    24         QList<XUPItem*> l; 
     25        QList<XUPProjectItem*> l; 
    2526        for ( int i = 0; i < rowCount(); i++ ) 
    26                 l << item( i, c ); 
     27                l << dynamic_cast<XUPProjectItem*> (item( i, c )); 
    2728        return l; 
    2829} 
  • v2/branches/dev/monkey/src/xupmanager/ProjectItemModel.h

    r1729 r2227  
    77 
    88class XUPItem; 
     9class XUPProjectItem; 
    910class FilteredProjectItemModel; 
    1011class ScopedProjectItemModel; 
     
    2526        void appendRow( XUPItem* ); 
    2627        // return all top level proejcts for column 
    27         QList<XUPItem*> topLevelProjects( int = 0 ) const; 
     28        QList<XUPProjectItem*> topLevelProjects( int = 0 ) const; 
    2829        // return the filtered model, ie a view that is beautifull for user 
    2930        FilteredProjectItemModel* filteredModel(); 
  • v2/branches/dev/monkey/src/xupmanager/XUPItem.cpp

    r1934 r2227  
    22#include "ProjectItemModel.h" 
    33#include "XUPIO.h" 
    4 #include "../coremanager/MonkeyCore.h" 
    5 #include "../pluginsmanager/PluginsManager.h" 
     4 
    65 
    76#include <QFile> 
     
    109 
    1110XUPItemInfos XUPItem::mXUPItemInfos; 
    12 QString XUPItem::mProjectSettingsScope = "ProjectSettings"; 
    1311 
    1412XUPItem::XUPItem( const QDomElement e, const QString& s, bool b ) 
     
    1715                registerItem(); 
    1816        setDomElement( e ); 
    19         loadProject( s ); 
     17        loadProject( s ); // FIXME Do it actual for Item ???             
    2018        setModified( b ); 
    2119} 
     
    223221                        if ( it->isProject() ) 
    224222                        { 
    225                                 connect( it, SIGNAL( aboutToClose( XUPItem* ) ), pit, SIGNAL( aboutToClose( XUPItem* ) ) ); 
    226                                 connect( it, SIGNAL( closed( XUPItem* ) ), pit, SIGNAL( closed( XUPItem* ) ) ); 
     223                                connect( it, SIGNAL( aboutToClose( XUPProjectItem* ) ), pit, SIGNAL( aboutToClose( XUPProjectItem* ) ) ); 
     224                                connect( it, SIGNAL( closed( XUPProjectItem* ) ), pit, SIGNAL( closed( XUPProjectItem* ) ) ); 
    227225                                connect( it, SIGNAL( installCommandRequested( const pCommand&, const QString& ) ), pit, SIGNAL( installCommandRequested( const pCommand&, const QString& ) ) ); 
    228226                                connect( it, SIGNAL( uninstallCommandRequested( const pCommand&, const QString& ) ), pit, SIGNAL( uninstallCommandRequested( const pCommand&, const QString& ) ) ); 
     
    385383} 
    386384 
    387 void XUPItem::closeProject() 
    388 { 
    389         // close child project 
    390         foreach ( XUPItem* it, children( false, false ) ) 
    391                 if ( it->isProject() ) 
    392                         it->closeProject(); 
    393         // tell we will close the project 
    394         emit aboutToClose( this ); 
    395         // emit closed 
    396         emit closed( this ); 
    397 } 
    398  
    399385void XUPItem::addFiles( const QStringList& files, XUPItem* scope, const QString& op ) 
    400386{ 
     
    715701        return v; 
    716702} 
    717  
    718 QStringList XUPItem::projectSettingsValues( const QString& variable, const QStringList& defaultValues ) const 
    719 { 
    720         // get the most top level project 
    721         if ( XUPItem* project = topLevelProject() ) 
    722                 // get project settings scope 
    723                 if ( XUPItem* scope = project->scope( mProjectSettingsScope, project, false ) ) 
    724                         // check for the variable in children 
    725                         foreach ( XUPItem* cit, scope->children( false, true ) ) 
    726                                 if ( cit->isType( "variable" ) && cit->defaultValue() == variable ) 
    727                                         return cit->variableValues(); 
    728         // else return default list 
    729         return defaultValues; 
    730 } 
    731  
    732 void XUPItem::setProjectSettingsValues( const QString& variable, const QStringList& values ) 
    733 { 
    734         // abort if no files 
    735         if ( variable.isEmpty() ) 
    736                 return; 
    737          
    738         // get top level project 
    739         XUPItem* project = topLevelProject(); 
    740         // get project settings scope 
    741         XUPItem* scope = project ? project->scope( mProjectSettingsScope, project, !values.isEmpty() ) : 0; 
    742         if ( !scope ) 
    743                 return; 
    744          
    745         // get variable item 
    746         XUPItem* vit = 0; 
    747         foreach ( XUPItem* cit, scope->children( false, true ) ) 
    748         { 
    749                 if ( cit->isType( "variable" ) && cit->defaultValue() == variable ) 
    750                 { 
    751                         vit = cit; 
    752                         break; 
    753                 } 
    754         } 
    755          
    756         // check variable exists or not 
    757         bool exists = vit; 
    758          
    759         // remove variable if needed 
    760         if ( exists && values.isEmpty() ) 
    761         { 
    762                 // remova variable 
    763                 vit->remove(); 
    764                 // update scope nested if needed 
    765                 if ( scope->isType( "scope" ) ) 
    766                         scope->setValue( "nested", scope->rowCount() > 1 ? "false" : "true" ); 
    767                 return; 
    768         } 
    769          
    770         // if not exists, and value is empty, do nothing 
    771         if ( !exists && values.isEmpty() ) 
    772                 return; 
    773          
    774         // create variable if needed 
    775         if ( !exists ) 
    776         { 
    777                 vit = scope->clone( false ); 
    778                 vit->setDomElement( scope->domElement().ownerDocument().createElement( "variable" ) ); 
    779                 scope->domElement().appendChild( vit->domElement() ); 
    780                 vit->setValue( vit->valueName(), variable ); 
    781                 vit->setValue( "multiline", "true" ); 
    782         } 
    783          
    784         // if same value, return 
    785         if ( vit->variableValues() == values ) 
    786                 return; 
    787         // clear values 
    788         while ( vit->hasChildren() ) 
    789                 vit->child( 0 )->remove(); 
    790         // set values 
    791         foreach ( const QString& value, values ) 
    792         { 
    793                 // create item value 
    794                 XUPItem* it = vit->clone( false ); 
    795                 it->setDomElement( vit->domElement().ownerDocument().createElement( "value" ) ); 
    796                 vit->domElement().appendChild( it->domElement() ); 
    797                 it->setValue( it->valueName(), value ); 
    798                 vit->appendRow( it ); 
    799         } 
    800          
    801         // append var item only at last will prevent multiple call of addFilteredValue from filtered view 
    802         if ( !exists ) 
    803                 scope->appendRow( vit ); 
    804          
    805         // update scope nested if needed 
    806         if ( scope->isType( "scope" ) ) 
    807                 scope->setValue( "nested", scope->rowCount() > 1 ? "false" : "true" ); 
    808 } 
    809  
    810 void XUPItem::addProjectSettingsValues( const QString& variable, const QStringList& values ) 
    811 { 
    812         // abort if no files or values 
    813         if ( variable.isEmpty() || values.isEmpty() ) 
    814                 return; 
    815          
    816         // get top level project 
    817         XUPItem* project = topLevelProject(); 
    818         // get project settings scope 
    819         XUPItem* scope = project ? project->scope( mProjectSettingsScope, project, !values.isEmpty() ) : 0; 
    820         if ( !scope ) 
    821                 return; 
    822          
    823         // get variable item 
    824         XUPItem* vit = 0; 
    825         foreach ( XUPItem* cit, scope->children( false, true ) ) 
    826         { 
    827                 if ( cit->isType( "variable" ) && cit->defaultValue() == variable ) 
    828                 { 
    829                         vit = cit; 
    830                         break; 
    831                 } 
    832         } 
    833          
    834         // check variable exists or not 
    835         bool exists = vit; 
    836          
    837         // create variable if needed 
    838         if ( !exists ) 
    839         { 
    840                 vit = scope->clone( false ); 
    841                 vit->setDomElement( scope->domElement().ownerDocument().createElement( "variable" ) ); 
    842                 scope->domElement().appendChild( vit->domElement() ); 
    843                 vit->setValue( vit->valueName(), variable ); 
    844                 vit->setValue( "multiline", "true" ); 
    845         } 
    846          
    847         // get existing values in variable 
    848         const QStringList existingValues = vit->variableValues(); 
    849         // set values 
    850         foreach ( const QString& value, values ) 
    851         { 
    852                 // create item value if needed 
    853                 if ( !existingValues.contains( value ) ) 
    854                 { 
    855                         XUPItem* it = vit->clone( false ); 
    856                         it->setDomElement( vit->domElement().ownerDocument().createElement( "value" ) ); 
    857                         vit->domElement().appendChild( it->domElement() ); 
    858                         it->setValue( it->valueName(), value ); 
    859                         vit->appendRow( it ); 
    860                 } 
    861         } 
    862          
    863         // append var item only at last will prevent multiple call of addFilteredValue from filtered view 
    864         if ( !exists ) 
    865                 scope->appendRow( vit ); 
    866          
    867         // update scope nested if needed 
    868         if ( scope->isType( "scope" ) ) 
    869                 scope->setValue( "nested", scope->rowCount() > 1 ? "false" : "true" ); 
    870 } 
    871  
    872 BuilderPlugin* XUPItem::builder( const QString& plugin ) const 
    873 { return MonkeyCore::pluginsManager()->plugin<BuilderPlugin*>( PluginsManager::stAll, projectSettingsValue( "BUILDER", plugin ) ); } 
    874  
    875 CompilerPlugin* XUPItem::compiler( const QString& plugin ) const 
    876 { return MonkeyCore::pluginsManager()->plugin<CompilerPlugin*>( PluginsManager::stAll, projectSettingsValue( "COMPILER", plugin ) ); } 
    877  
    878 DebuggerPlugin* XUPItem::debugger( const QString& plugin ) const 
    879 { return MonkeyCore::pluginsManager()->plugin<DebuggerPlugin*>( PluginsManager::stAll, projectSettingsValue( "DEBUGGER", plugin ) ); } 
    880  
    881 InterpreterPlugin* XUPItem::interpreter( const QString& plugin ) const 
    882 { return MonkeyCore::pluginsManager()->plugin<InterpreterPlugin*>( PluginsManager::stAll, projectSettingsValue( "INTERPRETER", plugin ) ); } 
    883  
    884 void XUPItem::addCommand( const pCommand& cmd, const QString& mnu ) 
    885 { 
    886         if ( cmd.isValid() ) 
    887         { 
    888                 emit installCommandRequested( cmd, mnu ); 
    889                 mCommands.insert( mnu, cmd ); 
    890         } 
    891 } 
    892  
    893 void XUPItem::installCommands() 
    894 { 
    895         // get plugins 
    896         BuilderPlugin* bp = builder(); 
    897         CompilerPlugin* cp = compiler(); 
    898         /* 
    899         DebuggerPlugin* dp = debugger(); 
    900         InterpreterPlugin* ip = interpreter(); 
    901         */ 
    902          
    903         // build command 
    904         if ( bp ) 
    905         { 
    906                 pCommand cmd = bp->buildCommand(); 
    907                 if ( cp ) 
    908                         cmd.addParsers( cp->compileCommand().parsers() ); 
    909                 cmd.setUserData( reinterpret_cast<quintptr>( &mCommands ) ); 
    910                 cmd.setProject( this ); 
    911                 cmd.setSkipOnError( false ); 
    912                 addCommand( cmd, "mBuilder/mBuild" ); 
    913         } 
    914          
    915         // compile file command 
    916         if ( cp ) 
    917         { 
    918                 pCommand cmd = cp->compileCommand(); 
    919                 cmd.setUserData( reinterpret_cast<quintptr>( &mCommands ) ); 
    920                 cmd.setProject( this ); 
    921                 cmd.setSkipOnError( false ); 
    922                 addCommand( cmd, "mBuilder/mBuild" ); 
    923         } 
    924          
    925         // install builder user command 
    926         if ( bp ) 
    927         { 
    928                 foreach ( pCommand cmd, bp->userCommands() ) 
    929                 { 
    930                         if ( cp ) 
    931                                 cmd.addParsers( cp->compileCommand().parsers() ); 
    932                         cmd.setUserData( reinterpret_cast<quintptr>( &mCommands ) ); 
    933                         cmd.setProject( this ); 
    934                         cmd.setSkipOnError( false ); 
    935                         addCommand( cmd, "mBuilder/mUserCommands" ); 
    936                 } 
    937         } 
    938          
    939         // install compiler user command 
    940         if ( cp ) 
    941         { 
    942                 foreach ( pCommand cmd, cp->userCommands() ) 
    943                 { 
    944                         cmd.setUserData( reinterpret_cast<quintptr>( &mCommands ) ); 
    945                         cmd.setProject( this ); 
    946                         cmd.setSkipOnError( false ); 
    947                         addCommand( cmd, "mBuilder/mUserCommands" ); 
    948                 } 
    949         } 
    950          
    951         // install debugger user command 
    952         // install interpreter user command 
    953 } 
    954  
    955 void XUPItem::uninstallCommands() 
    956 { 
    957         foreach ( const pCommand& cmd, mCommands.values() ) 
    958                 emit uninstallCommandRequested( cmd, mCommands.key( cmd ) ); 
    959         mCommands.clear(); 
    960 } 
  • v2/branches/dev/monkey/src/xupmanager/XUPItem.h

    r1847 r2227  
    5252         
    5353public: 
    54         static QString mProjectSettingsScope; 
    5554         
    5655        XUPItem( const QDomElement = QDomDocument().toElement(), const QString& = QString(), bool = false );