cargodialog.cpp

Go to the documentation of this file.

/***************************************************************************
                          cargodialog.cpp  -  description
                             -------------------
    begin                : Tue Oct 24 2000
    copyright            : (C) 2000 by Martin Bickel
    email                : bickel@asc-hq.org
 ***************************************************************************/

/***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/

#include <pgimage.h>
#include <pgtooltiphelp.h>
#include "cargodialog.h"
#include "cargowidget.h"
#include "vehicletypeselector.h"

#include "../containerbase.h"
#include "../paradialog.h"
#include "../messaginghub.h"
#include "../iconrepository.h"
#include "../vehicle.h"
#include "../gamemap.h"
#include "../containercontrols.h"

#include "../asc-mainscreen.h"
#include "../guiiconhandler.h"
#include "../guifunctions.h"
#include "../guifunctions-interface.h"
#include "../unitctrl.h"
#include "../cannedmessages.h"
#include "../replay.h"
#include "../dashboard.h"
#include "../dialog.h"
#include "../containerbase-functions.h"
#include "../resourcenet.h"

#include "../containerbase-functions.h"
#include "../gameoptions.h"

#include "selectionwindow.h"
#include "ammotransferdialog.h"
#include "unitinfodialog.h"

// #include "cargowidget.cpp"

const Vehicletype* selectVehicletype( ContainerBase* plant, const vector<Vehicletype*>& items );



class CargoDialog;

class SubWindow: public SigC::Object
{
   protected:
      CargoDialog* cargoDialog;
      PG_Widget* widget;
      
      SubWindow() : cargoDialog(NULL), widget(NULL) {};
      ContainerBase* container(); 
   public:
      virtual bool available( CargoDialog* cd ) = 0;
      virtual ASCString getASCTXTname() = 0;
      virtual ASCString getFullName() = 0;
      virtual void registerSubwindow( CargoDialog* cd );
      virtual void registerChilds( CargoDialog* cd );
      virtual void update() = 0;
      virtual ~SubWindow() {} ;
};


class SubWinButton : public PG_Button
{
   public:
      static const int buttonwidth = 47;
      static const int buttonheight = 28;

      SubWinButton( PG_Widget *parent, const SPoint& pos, SubWindow* subWindow ) : PG_Button( parent, PG_Rect( pos.x, pos.y, buttonwidth, buttonheight ), "", -1, "SubWinButton")
      {
         SetBackground( PRESSED, IconRepository::getIcon("cargo-buttonpressed.png").getBaseSurface() );
         SetBackground( HIGHLITED, IconRepository::getIcon("cargo-buttonhighlighted.png").getBaseSurface() );
         SetBackground( UNPRESSED, IconRepository::getIcon("cargo-buttonunpressed.png").getBaseSurface() );
         SetBorderSize(0,0,0);
         ASCString filename = ASCString("cargo-") + subWindow->getASCTXTname();
         SetIcon( IconRepository::getIcon( filename + ".png" ).getBaseSurface(), 
                  IconRepository::getIcon( filename + "-pressed.png" ).getBaseSurface(),
                  IconRepository::getIcon( filename + ".png" ).getBaseSurface() );
         SetToggle( true );
         new PG_ToolTipHelp ( this, subWindow->getFullName() );
      };
};


namespace CargoGuiFunctions {
   
   class MovementDestination : public GuiFunctions::Movement {
         PG_Widget& parent;
      public:
         MovementDestination( PG_Widget& masterParent ) : parent( masterParent)  {};
         
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
         {
            GuiFunctions::Movement::execute( pos, subject, num );
            if ( !pendingVehicleActions.move )
               parent.QuitModal();
         }
   };

   class CancelMovement : public GuiFunctions::Cancel {
         PG_Widget& parent;
      public:
         CancelMovement ( PG_Widget& masterParent ) : parent( masterParent)  {};
         
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num )
         {
            GuiFunctions::Cancel::execute( pos, subject, num );
            parent.QuitModal();
         }
   };
   

   class CloseDialog : public GuiFunction
   {
      CargoDialog& parent;
      public:
         CloseDialog( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };

   
   class Movement : public GuiFunction
   {
         CargoDialog& parent;
      public:
         Movement( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };


   class UnitProduction : public GuiFunction
   {
         CargoDialog& parent;
      public:
         UnitProduction( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };
   
   class UnitTraining : public GuiFunction
   {
         CargoDialog& parent;
      public:
         UnitTraining( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };

   class RefuelUnit : public GuiFunction
   {
         CargoDialog& parent;
      public:
         RefuelUnit( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };
   
   class RefuelUnitDialog : public GuiFunction
   {
      CargoDialog& parent;
      public:
         RefuelUnitDialog( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };

   class RepairUnit : public GuiFunction
   {
      CargoDialog& parent;
      public:
         RepairUnit( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };
   
   class MoveUnitUp : public GuiFunction
   {
         CargoDialog& parent;
      public:
         MoveUnitUp ( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };
   
   class MoveUnitIntoInnerContainer : public GuiFunction
   {
      CargoDialog& parent;
      public:
         MoveUnitIntoInnerContainer ( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };

   
   class OpenContainer: public GuiFunction
   {
         CargoDialog& parent;
      public:
         OpenContainer( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };
   
   class RecycleUnit : public GuiFunction
   {
      CargoDialog& parent;
      public:
         RecycleUnit( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };

   class UnitInfo : public GuiFunction
   {
      CargoDialog& parent;
      public:
         UnitInfo( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         bool checkForKey( const SDL_KeyboardEvent* key, int modifier, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };

   class TransferUnitControl : public GuiFunction
   {
      CargoDialog& parent;
      public:
         TransferUnitControl( CargoDialog& masterParent ) : parent( masterParent)  {};
         bool available( const MapCoordinate& pos, ContainerBase* subject, int num );
         void execute( const MapCoordinate& pos, ContainerBase* subject, int num );
         Surface& getImage( const MapCoordinate& pos, ContainerBase* subject, int num );
         ASCString getName( const MapCoordinate& pos, ContainerBase* subject, int num );
   };

   
   
}; // namespace CargoGuiFunctions


class BuildingControlWindow;
class CargoInfoWindow;

class CargoDialog : public Panel
{

      ContainerControls containerControls;
   
      GuiIconHandler guiIconHandler;
      
      ContainerBase* container;
      bool setupOK;
      Surface infoImage;

      typedef vector<SubWindow*> Activesubwindows;
      Activesubwindows activesubwindows;
      
      typedef deallocating_vector<SubWindow*> Subwindows;
      Subwindows subwindows;

      vector<SubWinButton*> subWinButtons;

      CargoWidget* cargoWidget;
      SubWindow* researchWindow;
      SubWindow* matterWindow;
      BuildingControlWindow* buildingControlWindow;

      CargoInfoWindow* ciw;
      
      bool eventKeyDown(const SDL_KeyboardEvent* key)
      {
         if ( key->keysym.sym == SDLK_ESCAPE ) {
            QuitModal();
            return true;
         }
         return false;
      };



      void registerSpecialDisplay( const ASCString& name )
      {
         SpecialDisplayWidget* sdw = dynamic_cast<SpecialDisplayWidget*>( FindChild( name, true ) );
         if ( sdw )
            sdw->display.connect( SigC::slot( *this, &CargoDialog::painter ));
      };

      void registerSpecialInput( const ASCString& name )
      {
         SpecialInputWidget* siw = dynamic_cast<SpecialInputWidget*>( FindChild( name, true ) );
         if ( siw )
            siw->sigMouseButtonDown.connect( SigC::slot( *this, &CargoDialog::onClick ));
      };

      bool onClick ( PG_MessageObject* obj, const SDL_MouseButtonEvent* event )
      {
         PG_Widget* w = dynamic_cast<PG_Widget*>(obj);
         if ( w ) {
            // click( w->GetName() );
            return true;
         }
         return false;
      };

      void onUnitClick ( Vehicle* veh,SPoint pos, bool first )
      {
         // if ( veh )
         if ( mainScreenWidget&& mainScreenWidget->getGuiHost() && (!first || CGameOptions::Instance()->mouse.singleClickAction) ) { 
            SPoint iconPos = pos;
            if ( veh ) {
               iconPos.x -= smallGuiIconSizeX/2;
               iconPos.y -= smallGuiIconSizeY/2;
            } else {
               iconPos.x += 2;
               iconPos.y += 2;
            }

            mainScreenWidget->getGuiHost()->showSmallIcons( this, iconPos, false );
         }
            
      };

      void clearSmallIcons( )
      {
         if ( mainScreenWidget && mainScreenWidget->getGuiHost() )
            mainScreenWidget->getGuiHost()->clearSmallIcons();
      }
         

      
      void painter ( const PG_Rect &src, const ASCString& name, const PG_Rect &dst)
      {
         Surface screen = Surface::Wrap( PG_Application::GetScreen() );

         if ( name == "unitpad_unitsymbol" ) {
            Vehicle* v = dynamic_cast<Vehicle*>(container);
            if ( v ) 
               v->paint( screen, SPoint( dst.x, dst.y ));
         }
      };

      bool activate_i( int pane )
      {
         if ( pane >= 0 && pane < activesubwindows.size() ) {
            activate( activesubwindows[pane]->getASCTXTname() );
            activesubwindows[pane]->update();
         }
         return true;
      }

      void activate( const ASCString& pane )
      {
         BulkGraphicUpdates bgu( this );
         for ( int i = 0; i < activesubwindows.size(); ++i )
            if ( activesubwindows[i]->getASCTXTname() != pane )
               hide( activesubwindows[i]->getASCTXTname() );

         for ( int i = 0; i < activesubwindows.size(); ++i )
            if ( activesubwindows[i]->getASCTXTname() == pane )
               show( activesubwindows[i]->getASCTXTname() );

         for ( int i = 0; i< subWinButtons.size(); ++i )
            subWinButtons[i]->SetPressed( activesubwindows[i]->getASCTXTname() == pane );
      };


      void registerGuiFunctions( GuiIconHandler& handler )
      {
         registerCargoGuiFunctions( handler );
         handler.registerUserFunction( new CargoGuiFunctions::Movement( *this ) );
         handler.registerUserFunction( new CargoGuiFunctions::RefuelUnit( *this ) );
         handler.registerUserFunction( new CargoGuiFunctions::RefuelUnitDialog( *this ) );
         handler.registerUserFunction( new CargoGuiFunctions::RepairUnit( *this ) );
         handler.registerUserFunction( new CargoGuiFunctions::UnitProduction( *this ));
         handler.registerUserFunction( new CargoGuiFunctions::UnitTraining( *this ));
         handler.registerUserFunction( new CargoGuiFunctions::MoveUnitUp( *this ));
         handler.registerUserFunction( new CargoGuiFunctions::MoveUnitIntoInnerContainer( *this ));
         handler.registerUserFunction( new CargoGuiFunctions::OpenContainer( *this ));
         handler.registerUserFunction( new CargoGuiFunctions::RecycleUnit( *this ));
         handler.registerUserFunction( new CargoGuiFunctions::UnitInfo( *this ));
         handler.registerUserFunction( new CargoGuiFunctions::TransferUnitControl( *this ));
         handler.registerUserFunction( new CargoGuiFunctions::CloseDialog( *this ));
      }

      void checkStoringPosition( Vehicle* unit )
      {
         if ( mainScreenWidget&& mainScreenWidget->getGuiHost() ) {
            mainScreenWidget->getGuiHost()->eval( container->getPosition(), unit );
         }
         
         if ( mainScreenWidget && mainScreenWidget->getUnitInfoPanel() )
            mainScreenWidget->getUnitInfoPanel()->showUnitData( unit, NULL, NULL, true );
      }

      void updateLoadMeter()
      {
         if ( container->baseType->maxLoadableWeight > 0 ) 
            setBargraphValue ( "LoadingMeter", float( container->cargoWeight()) / container->baseType->maxLoadableWeight );
      }
      
      void dragUnitToInnerContainer( Vehicle* draggedUnit, Vehicle* targetUnit )
      {
         if ( !draggedUnit )
            return;
         
         if ( draggedUnit != targetUnit ) {
            if ( targetUnit ) {
               containerControls.moveUnitDown( draggedUnit, targetUnit );
            } else {
               if ( container->getCarrier() )
                  containerControls.moveUnitUp( draggedUnit );
               else {
                    
               }
            }
         }
         cargoChanged();
      }
      
      bool dragUnitToInnerContainerAvail( Vehicle* draggedUnit, Vehicle* targetUnit )
      {
         return containerControls.moveUnitDownAvail( draggedUnit, targetUnit );
      }
      
      void dragInProcess()
      {
         if ( mainScreenWidget && mainScreenWidget->getGuiHost() ) 
            mainScreenWidget->getGuiHost()->clearSmallIcons();
      }
      
      void dragAborted()
      {
         // to redraw everything
         cargoChanged();
      }
      
      
   public:

      CargoDialog (PG_Widget *parent, ContainerBase* cb );

      void addAvailableSubwin( SubWindow* w )
      {
         activesubwindows.push_back( w );
      };

      void updateResourceDisplay()
      {
         setLabelText( "energyavail", container->getResource(maxint, 0, true ) );
         setLabelText( "materialavail", container->getResource(maxint, 1, true ) );
         setLabelText( "fuelavail", container->getResource(maxint, 2, true ) );
         setLabelText( "numericaldamage", container->damage );
      }


      Vehicle* getMarkedUnit()
      {
         if ( cargoWidget )
            return cargoWidget->getMarkedUnit();
         else
            return NULL;
      }
      
      void cargoChanged()
      {
         //unitHighLight.setNew( unitHighLight.getMark() );
         if ( cargoWidget ) {
            cargoWidget->redrawAll();
            if ( mainScreenWidget && mainScreenWidget->getUnitInfoPanel() )
               mainScreenWidget->getUnitInfoPanel()->showUnitData( cargoWidget->getMarkedUnit(), NULL, NULL, true );
            
            checkStoringPosition( cargoWidget->getMarkedUnit() );
         }
         sigCargoChanged();
         updateResourceDisplay();
         showAmmo();
         updateLoadMeter();
      }
      
      int RunModal()
      {
         if ( setupOK )
            return Panel::RunModal();
         return 0;
      }

      bool ProcessEvent ( const SDL_Event *   event,bool   bModal = false  )
      {
         // the unit info panel must get the events first. If a unit is renamed and a character entered, this
         // key event shall go to the renaming - and not to the unit actions.
         if ( mainScreenWidget && mainScreenWidget->getUnitInfoPanel() ) 
            if ( mainScreenWidget->getUnitInfoPanel()->ProcessEvent( event, bModal ))
               return true;

         if ( mainScreenWidget && mainScreenWidget->getGuiHost() ) 
            if ( mainScreenWidget->getGuiHost()->ProcessEvent( event, bModal ))
               return true;
         
         if ( Panel::ProcessEvent( event, bModal )) 
            return true;
             
         return false;
      }

      void showAmmo()
      {
         setLabelText( "cmmun", container->getAmmo( cwcruisemissile, maxint, true ));
         setLabelText( "minemun", container->getAmmo( cwminen, maxint, true ));
         setLabelText( "bombmun", container->getAmmo( cwbombn, maxint, true ));
         setLabelText( "lmmun", container->getAmmo( cwlargemissilen, maxint, true ));
         setLabelText( "smmun", container->getAmmo( cwsmallmissilen, maxint, true ));
         setLabelText( "mgmun", container->getAmmo( cwmachinegunn, maxint, true ));
         setLabelText( "canmun", container->getAmmo( cwcannonn, maxint, true ));
         setLabelText( "torpmun", container->getAmmo( cwtorpedon, maxint, true ));
      }

      void userHandler( const ASCString& label, PropertyReadingContainer& pc, PG_Widget* parent, WidgetParameters widgetParams );

      ContainerBase* getContainer() { return container; };

      GameMap* getMap() { if ( container ) return container->getMap(); else return NULL; };
      
      ContainerControls& getControls() { return containerControls; };

      SigC::Signal0<void>  sigCargoChanged;


      ~CargoDialog()
      {
         if ( setupOK ) 
            NewGuiHost::popIconHandler();

      }

};





void cargoDialog( ContainerBase* cb )
{
   CargoDialog cd ( NULL, cb );
   cd.Show();
   cd.RunModal();
}





class VehicleProduction_SelectionItemFactory: public VehicleTypeSelectionItemFactory  {
      bool fillResources;
      bool fillAmmo;
      const ContainerBase* plant;

      // is initialized by the constructor's call to filterVehicleTypes
      Container* produceables;
      
      Container& filterVehicleTypes( const Container& vehicles, const ContainerBase* productionplant )
      {
         produceables = new Container();
         for ( Container::const_iterator i = vehicles.begin(); i != vehicles.end(); ++i ) {
            if ( productionplant->getMap()->getgameparameter( cgp_produceOnlyResearchedStuffInternally )) {
               ContainerConstControls cc ( productionplant );
               if ( !(cc.unitProductionPrerequisites( *i ) & ~(1+2+4)))  // we are filtering out the bits for lack of resource
                  produceables->push_back( *i );
            } else
               produceables->push_back( *i );
         }

         return *produceables;
      }

   protected:
      void vehicleTypeSelected( const Vehicletype* type, bool mouse )
      {
         sigVehicleTypeSelected( type, mouse );
      }

      void itemMarked( const SelectionWidget* widget, bool mouse )
      {
         if ( !widget )
            return;
            
         const VehicleTypeBaseWidget* fw = dynamic_cast<const VehicleTypeBaseWidget*>(widget);
         assert( fw );
         sigVehicleTypeMarked( fw->getVehicletype() );
      }

      const Container& getOriginalItems() { 
         delete produceables;
         filterVehicleTypes( plant->getProduction(), plant );
         return *produceables; 
      };

   public:
      VehicleProduction_SelectionItemFactory( Resources plantResources, const ContainerBase* productionplant )
         : VehicleTypeSelectionItemFactory( plantResources, filterVehicleTypes( productionplant->getProduction(), productionplant), productionplant->getMap()->getCurrentPlayer() ), 
           fillResources(true), 
           fillAmmo(true), 
           plant(productionplant)
      {
      };
      

      bool getAmmoFilling()
      {
          if ( plant->baseType->hasFunction(ContainerBaseType::AmmoProduction))
             return fillAmmo;
          else
             return false;
      }
      
      bool setAmmoFilling( bool value )
      {
         fillAmmo = value;
         reloadAllItems();
         return true;
      }
      
      bool getResourceFilling()
      {
         return fillResources;
      }
      
      bool setResourceFilling( bool value )
      {
         fillResources = value;
         reloadAllItems();
         return true;
      }

     
      Resources getCost( const Vehicletype* type )
      {
         Resources cost = plant->getProductionCost( type );
         if ( fillResources )
            cost += Resources( 0, type->getStorageCapacity(plant->getMap()->_resourcemode).material, type->getStorageCapacity(plant->getMap()->_resourcemode).fuel );

         if ( fillAmmo )
            for ( int w = 0; w < type->weapons.count; ++w )
               if ( type->weapons.weapon[w].requiresAmmo() ) {
                  int wt = type->weapons.weapon[w].getScalarWeaponType();
                  cost += Resources( cwaffenproduktionskosten[wt][0], cwaffenproduktionskosten[wt][1], cwaffenproduktionskosten[wt][2] ) * type->weapons.weapon[w].count;
               }
         return cost;
      };

      SigC::Signal2<void,const Vehicletype*, bool > sigVehicleTypeSelected;
      SigC::Signal1<void,const Vehicletype* > sigVehicleTypeMarked;
      
      ~VehicleProduction_SelectionItemFactory()
      {
         delete produceables;  
      }
      
};


class AddProductionLine_SelectionItemFactory: public VehicleTypeSelectionItemFactory  {
      ContainerBase* plant;
   public:
      AddProductionLine_SelectionItemFactory( ContainerBase* my_plant, const Container& types ) : VehicleTypeSelectionItemFactory( my_plant->getResource(Resources(maxint,maxint,maxint), true), types, my_plant->getMap()->getCurrentPlayer() ), plant(my_plant)
      {
         
      };
      
      void vehicleTypeSelected( const Vehicletype* type, bool mouse )
      {
         ContainerControls cc( plant );
         int res = cc.buildProductionLine( type );
         if ( res < 0 )
            errorMessage( getmessage ( -res ));
      }
      
      Resources getCost( const Vehicletype* type )
      {
         ContainerControls cc ( plant );
         return cc.buildProductionLineResourcesNeeded( type );
      };
};


class VehicleProduction_SelectionWindow : public ASC_PG_Dialog {
      const Vehicletype* selected;
      const Vehicletype* finallySelected;
      ItemSelectorWidget* isw;
      VehicleProduction_SelectionItemFactory* factory;
      ContainerBase* my_plant;
   protected:
      void vtMarked( const Vehicletype* vt )
      {
         vtSelected( vt, true );
      }

      void vtSelected( const Vehicletype* vt, bool mouse )
      {
         selected = vt;

         if ( !mouse ) // enter pressed
            produce();
      };

      bool produce()
      {
         if ( selected ) {
            finallySelected = selected;
            quitModalLoop(0);
            return true;
         } else
            return false;
      }


      bool closeWindow()
      {
         selected = NULL;
         return ASC_PG_Dialog::closeWindow();
      }
      
      bool quitSignalled()
      {
         selected = NULL;
         QuitModal();
         return true;
      };
      
      void reLoadAndUpdate()
      {
         factory->setAvailableResource(my_plant->getResource(Resources(maxint,maxint,maxint)));
         isw->reLoad( true );
      }

      bool eventKeyDown(const SDL_KeyboardEvent* key)
      {
         int mod = SDL_GetModState() & ~(KMOD_NUM | KMOD_CAPS | KMOD_MODE);
         if ( mod )
            return false;

         if ( key->keysym.sym == SDLK_ESCAPE ) {
            closeWindow();
            return true;
         }

         return false;
      }


   public:
      VehicleProduction_SelectionWindow( PG_Widget *parent, const PG_Rect &r, ContainerBase* plant ) : ASC_PG_Dialog( parent, r, "Choose Vehicle Type" ), selected(NULL), finallySelected(NULL), isw(NULL), factory(NULL), my_plant( plant )
      {
         factory = new VehicleProduction_SelectionItemFactory( plant->getResource(Resources(maxint,maxint,maxint), true), plant );

         factory->setResourceFilling ( CGameOptions::Instance()->unitProduction.fillResources );


         factory->sigVehicleTypeSelected.connect ( SigC::slot( *this, &VehicleProduction_SelectionWindow::vtSelected ));
         factory->sigVehicleTypeMarked.connect ( SigC::slot( *this, &VehicleProduction_SelectionWindow::vtMarked ));

         isw = new ItemSelectorWidget( this, PG_Rect(10, GetTitlebarHeight(), r.Width() - 20, r.Height() - GetTitlebarHeight() - 40), factory );
         isw->sigQuitModal.connect( SigC::slot( *this, &VehicleProduction_SelectionWindow::quitSignalled));

         factory->reloadAllItems.connect( SigC::slot( *this, &VehicleProduction_SelectionWindow::reLoadAndUpdate ));
         
         
         int y = GetTitlebarHeight() + isw->Height();
         PG_CheckButton* fillRes = new PG_CheckButton( this, PG_Rect( 10, y + 2, r.Width() / 2 - 50, 20), "Fill with Resources" );
         

         if ( factory->getResourceFilling() ) 
            fillRes->SetPressed();
         fillRes->sigClick.connect( SigC::slot( *factory, &VehicleProduction_SelectionItemFactory::setResourceFilling ));
         
         if ( plant->baseType->hasFunction(ContainerBaseType::AmmoProduction)) {
            factory->setAmmoFilling( CGameOptions::Instance()->unitProduction.fillAmmo );
            PG_CheckButton* fillAmmo = new PG_CheckButton( this, PG_Rect( 10, y + 20, r.Width() / 2 - 50, 20), "Fill with Ammo" );
            if ( factory->getAmmoFilling() ) 
               fillAmmo->SetPressed();
            fillAmmo->sigClick.connect( SigC::slot( *factory, &VehicleProduction_SelectionItemFactory::setAmmoFilling ));
         } else
            factory->setAmmoFilling( false );

         PG_Rect rr ( r.Width() / 2 + 10, y + 2, (r.Width() - 20) - (r.Width() / 2 + 10) , 35);
         PG_Button* b  = new PG_Button( this, PG_Rect( rr.x + rr.h + 5, rr.y, rr.w - 40, rr.h ) , "Produce" );
         b->sigClick.connect( SigC::slot( *this,&VehicleProduction_SelectionWindow::produce ));
         
         if ( !plant->baseType->hasFunction(ContainerBaseType::NoProductionCustomization)) {
            PG_Button* b2 = new PG_Button( this, PG_Rect( rr.x, rr.y, rr.h, rr.h ), "+" );
            b2->sigClick.connect( SigC::slot( *this, &VehicleProduction_SelectionWindow::addProductionLine ));
            new PG_ToolTipHelp( b2, "Add production line");
   
            PG_Button* b3 = new PG_Button( this, PG_Rect( rr.x - rr.h - 5, rr.y, rr.h, rr.h ), "-" );
            b3->sigClick.connect( SigC::slot( *this, &VehicleProduction_SelectionWindow::removeProductionLine ));
            new PG_ToolTipHelp( b3, "Remove production line");
         }

         
         SetTransparency(0);
      };

      bool addProductionLine()
      {
         ContainerControls cc ( my_plant );
         {
            ItemSelectorWindow isw( NULL, PG_Rect( 100, 150, 400, 400 ),  "choose production line", new AddProductionLine_SelectionItemFactory( my_plant, cc.productionLinesBuyable() ));
            isw.Show();
            isw.RunModal();
         }
         reLoadAndUpdate();
         return true;
      }

      bool removeProductionLine()
      {
         if ( selected && choice_dlg("do you really want to remove this production line ?","~y~es","~n~o") == 1) {
            ContainerControls cc ( my_plant );
            cc.removeProductionLine( selected );
            reLoadAndUpdate();
         }
         return true;
      }

      
      bool fillWithAmmo()
      {
         return factory->getAmmoFilling();
      }

      bool fillWithResources()
      {
         return factory->getResourceFilling();
      }
      

      const Vehicletype* getVehicletype() { return finallySelected; };
};


/*
const Vehicletype* selectVehicletype( ContainerBase* plant, const vector<Vehicletype*>& items )
{
   VehicleTypeSelectionWindow fsw( NULL, PG_Rect( 10, 10, 400, 500 ), plant, items );
   fsw.Show();
   fsw.RunModal();
   const Vehicletype* v = fsw.getVehicletype();
   return v;
}

*/


void SubWindow::registerSubwindow( CargoDialog* cd )
{
   cargoDialog = cd;
   cd->addAvailableSubwin( this );
}

void SubWindow::registerChilds( CargoDialog* cd )
{
   widget = cd->FindChild( getASCTXTname(), true);
   if ( !widget )
      warning( "Could not find widget with name " + getASCTXTname() );
}


ContainerBase* SubWindow::container()
{
   return cargoDialog->getContainer();
}

/*
const int subWindowNum = 11;
static const char* subWindowName[subWindowNum] =
{ "ammotransfer", "ammoproduction", "info", "cargoinfo", "conventionalpower", "mining", "netcontrol", "research", "resourceinfo", "solarpower", "windpower"
};
*/



class SolarPowerWindow : public SubWindow {
  
   public:
      bool available( CargoDialog* cd )
      {
         if ( !cd->getMap()->getCurrentPlayer().diplomacy.isAllied( cd->getContainer() ))
            return false;
         
         return cd->getContainer()->baseType->hasFunction( ContainerBaseType::SolarPowerPlant  );
      };
      
      ASCString getASCTXTname()
      {
         return "solarpower";
      };

      ASCString getFullName()
      {
         return "Solar Power Generation";
      };
      
      void update()
      {
         cargoDialog->setLabelText( "MaxPower", container()->maxplus.energy, widget );
      
         static const char* weathernames[] = {"terrain_weather_dry.png",
                                              "terrain_weather_lightrain.png",
                                              "terrain_weather_heavyrain.png",
                                              "terrain_weather_lightsnow.png",
                                              "terrain_weather_heavysnow.png",
                                              "terrain_weather_ice.png" };


         SolarPowerplant solarPowerPlant ( container() );
         Resources plus = solarPowerPlant.getPlus();
         cargoDialog->setLabelText( "CurrentPower", plus.energy, widget );
         cargoDialog->setImage( "Weather", weathernames[ container()->getMap()->getField( container()->getPosition() )->getweather() ], widget );
      }
};

class WindPowerWindow : public SubWindow {
   public:
      bool available( CargoDialog* cd )
      {
         if ( !cd->getMap()->getCurrentPlayer().diplomacy.isAllied( cd->getContainer() ))
            return false;
         
         return cd->getContainer()->baseType->hasFunction( ContainerBaseType::WindPowerPlant  );
      };
      
      ASCString getASCTXTname()
      {
         return "windpower";
      };

      ASCString getFullName()
      {
         return "Wind Power Generation";
      };


      void update()
      {
         cargoDialog->setLabelText( "MaxPower", container()->maxplus.energy, widget );
      
         WindPowerplant windPowerPlant ( container() );
         Resources plus = windPowerPlant.getPlus();
         cargoDialog->setLabelText( "CurrentPower", plus.energy, widget );
         
#ifdef WEATHERGENERATOR
         if ( container()->getMap()->weatherSystem )
            cargoDialog->setLabelText( "Weather", container()->getMap()->weatherSystem->getCurrentWindSpeed(), widget );
#else
         cargoDialog->setLabelText( "Weather", container()->getMap()->weather.windSpeed, widget );
#endif
      }
};

class NetControlWindow : public SubWindow {

   private:

      bool click( PG_Button* b, int x, int y )
      {
         return true;
      }

      PG_Button* findButton( int x, int y )
      {
         char c = 'a' + x;
         ASCString buttonName = "Button" + ASCString::toString(y) + c;
         return dynamic_cast<PG_Button*>( widget->FindChild( buttonName, true ) );
      }
      
   public:
      bool available( CargoDialog* cd )
      {
         if ( !cd->getMap()->getCurrentPlayer().diplomacy.isAllied( cd->getContainer() ))
            return false;
         
         return dynamic_cast<Building*>(cd->getContainer()) != NULL;
      };
      
      ASCString getASCTXTname()
      {
         return "netcontrol";
      };
      
      ASCString getFullName()
      {
         return "Resource Network Control";
      };


      void registerChilds( CargoDialog* cd )
      {
         SubWindow::registerChilds( cd );

         if ( widget ) {
            for ( int x = 0; x < 3; ++x ) {
               for ( int y = 0; y < 4; ++y ) {
                  PG_Button* b = findButton( x, y );
                  if ( b ) {
                     b->sigClick.connect( SigC::bind( SigC::bind( SigC::slot( *this, &NetControlWindow::click ), x), y));
                     if( y >= 2)
                        b->