# include <ieeefp.h>
#endif
-SG_USING_STD(string);
+using std::string;
#include "AIAircraft.hxx"
#include "performancedata.hxx"
#include <Traffic/Schedule.hxx>
#include <string>
-SG_USING_STD(string);
+using std::string;
class PerformanceData;
#include "AIManager.hxx"
#include "AIBase.hxx"
-SG_USING_STD(vector);
-SG_USING_STD(list);
+using std::vector;
+using std::list;
class FGAIBallistic : public FGAIBase {
#include <Main/fg_props.hxx>
-SG_USING_STD(string);
-SG_USING_STD(list);
+using std::string;
+using std::list;
class FGAIManager;
class FGAIFlightPlan;
#include <simgear/compiler.h>
-SG_USING_STD(string);
-SG_USING_STD(list);
+using std::string;
+using std::list;
#include "AIShip.hxx"
#include "AIBase.hxx"
-SG_USING_STD(vector);
-SG_USING_STD(string);
+using std::vector;
+using std::string;
class FGAIFlightPlan {
#include <Environment/environment_mgr.hxx>
#include <Environment/environment.hxx>
-SG_USING_STD(iostream);
+using std::iostream;
void FGAIFlightPlan::evaluateRoutePart(double deplat,
double deplon,
#include <Traffic/SchedFlight.hxx>
#include <Traffic/Schedule.hxx>
-SG_USING_STD(list);
+using std::list;
class FGAIThermal;
#include <string>
#include <math.h>
-SG_USING_STD(string);
+using std::string;
#include "AIStatic.hxx"
#include "AIBase.hxx"
#include <string>
-SG_USING_STD(string);
+using std::string;
class FGAIStatic : public FGAIBase {
#include <cstdlib>
#include <time.h>
-SG_USING_STD(string);
+using std::string;
#include "AIStorm.hxx"
#include "AIBase.hxx"
#include <string>
-SG_USING_STD(string);
+using std::string;
class FGAIStorm : public FGAIBase {
#include <string>
#include <math.h>
-SG_USING_STD(string);
+using std::string;
#include "AIThermal.hxx"
#include "AIBase.hxx"
#include <string>
-SG_USING_STD(string);
+using std::string;
class FGAIThermal : public FGAIBase {
#include <Main/fg_props.hxx>
-SG_USING_STD(vector);
-SG_USING_STD(string);
-SG_USING_STD(list);
+using std::vector;
+using std::string;
+using std::list;
class FGAIBase;
#include <string>
#include <vector>
-SG_USING_STD(string);
-SG_USING_STD(vector);
+using std::string;
+using std::vector;
typedef vector<int> intVec;
#include <string>
#include <math.h>
-SG_USING_STD(string);
+using std::string;
#include "ATC.hxx"
#include "ATCmgr.hxx"
#include "AILocalTraffic.hxx"
#include <string>
-SG_USING_STD(string);
+using std::string;
class FGAIGAVFRTraffic : public FGAILocalTraffic {
#include <string>
#include <math.h>
-SG_USING_STD(string);
+using std::string;
#include "ATCmgr.hxx"
#include "AILocalTraffic.hxx"
struct Gate;
#include <string>
-SG_USING_STD(string);
+using std::string;
enum TaxiState {
TD_INBOUND,
#include "ATCutils.hxx"
#include "commlist.hxx"
-SG_USING_STD(list);
-SG_USING_STD(cout);
+using std::list;
+using std::cout;
using namespace simgear;
#include "ATCmgr.hxx"
#include "AIEntity.hxx"
-SG_USING_STD(list);
+using std::list;
class FGAIMgr : public SGSubsystem
#include <simgear/sound/soundmgr_openal.hxx>
#include <math.h>
#include <string>
-SG_USING_STD(string);
+using std::string;
#include "AIPlane.hxx"
#include "ATCVoice.hxx"
-SG_USING_STD(ostream);
-SG_USING_STD(string);
-SG_USING_STD(ios);
+using std::ostream;
+using std::string;
+using std::ios;
enum plane_type {
UNKNOWN,
#include <sstream>
-SG_USING_STD(ostringstream);
+using std::ostringstream;
FGATCDialog *current_atcdialog;
#include "ATC.hxx"
-SG_USING_STD(vector);
-SG_USING_STD(map);
+using std::vector;
+using std::map;
class NewGUI;
#include <simgear/sound/sample_openal.hxx>
-SG_USING_STD(map);
-SG_USING_STD(list);
-SG_USING_STD(string);
+using std::map;
+using std::list;
+using std::string;
struct WordData {
#include "tower.hxx"
#include "approach.hxx"
-SG_USING_STD(string);
-SG_USING_STD(list);
-SG_USING_STD(map);
+using std::string;
+using std::list;
+using std::map;
// Structure for holding details of the ATC frequencies at a given airport, and whether they are in the active list or not.
// These can then be cross referenced with the commlists which are stored by frequency or bucket.
#include <math.h>
#include <simgear/math/point3d.hxx>
#include <string>
-SG_USING_STD(string);
+using std::string;
// These are defined here because I had a problem with SG_DEGREES_TO_RADIANS
#define DCL_PI 3.1415926535f
#include <stdlib.h> // atoi()
#include <stdio.h> // sprintf
#include <string>
-SG_USING_STD(string);
+using std::string;
#include <iostream>
-SG_USING_STD(cout);
+using std::cout;
#include <simgear/misc/sg_path.hxx>
#include "ATC.hxx"
#include "atis.hxx"
-SG_USING_STD(list);
-SG_USING_STD(map);
-SG_USING_STD(vector);
-SG_USING_STD(string);
+using std::list;
+using std::map;
+using std::vector;
+using std::string;
// A list of ATC stations
typedef list < ATCData > comm_list_type;
#include "AILocalTraffic.hxx"
#include "ATCmgr.hxx"
-SG_USING_STD(ifstream);
-SG_USING_STD(cout);
+using std::ifstream;
+using std::cout;
node::node() {
}
#include "AILocalTraffic.hxx"
-SG_USING_STD(cout);
+using std::cout;
// TowerPlaneRec
#include "ATC.hxx"
#include "transmission.hxx"
-SG_USING_STD(map);
-SG_USING_STD(vector);
+using std::map;
+using std::vector;
class FGTransmissionList {
#include <Network/net_ctrls.hxx>
#include <Network/net_fdm.hxx>
-SG_USING_STD(deque);
+using std::deque;
class FGReplayData {
#include <string>
-SG_USING_STD(string);
+using std::string;
#include "simple.hxx"
#include "runways.hxx"
#include <simgear/math/sg_geodesy.hxx>
-SG_USING_STD(string);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::string;
+using std::cout;
+using std::endl;
int main( int argc, char **argv ) {
#include <string>
#include <vector>
-SG_USING_STD(string);
-SG_USING_STD(vector);
-SG_USING_STD(sort);
-SG_USING_STD(random_shuffle);
+using std::string;
+using std::vector;
+using std::sort;
+using std::random_shuffle;
#include "simple.hxx"
#include "dynamics.hxx"
#include "groundnetwork.hxx"
#include <algorithm>
-SG_USING_STD(sort);
+using std::sort;
/*****************************************************************************
* Helper function for parsing position string
#include <string>
#include <simgear/compiler.h>
-SG_USING_STD(string);
-SG_USING_STD(vector);
+using std::string;
+using std::vector;
class FGTaxiSegment;
typedef vector<FGTaxiSegment*> FGTaxiSegmentVector;
#include <string>
#include <vector>
-SG_USING_STD(string);
-SG_USING_STD(vector);
+using std::string;
+using std::vector;
#include "gnnode.hxx"
#include "parking.hxx"
#include "gnnode.hxx"
-SG_USING_STD(string);
-SG_USING_STD(vector);
+using std::string;
+using std::vector;
class FGTaxiRoute;
#include "runwayprefs.hxx"
-SG_USING_STD(string);
+using std::string;
class FGRunwayPreferenceXMLLoader : public XMLVisitor {
public:
#include <simgear/compiler.h>
-SG_USING_STD(vector);
-SG_USING_STD(string);
+using std::vector;
+using std::string;
typedef vector<time_t> timeVec;
typedef vector<time_t>::const_iterator timeVecConstIterator;
#include "runways.hxx"
-SG_USING_STD(istream);
-SG_USING_STD(multimap);
+using std::istream;
+using std::multimap;
// add an entry to the list
#include <string>
#include <map>
-SG_USING_STD(string);
-SG_USING_STD(multimap);
+using std::string;
+using std::multimap;
struct ltstr {
#include "simple.hxx"
#include "xmlloader.hxx"
-SG_USING_STD(sort);
-SG_USING_STD(random_shuffle);
+using std::sort;
+using std::random_shuffle;
#include "dynamics.hxx"
-SG_USING_STD(string);
-SG_USING_STD(map);
-SG_USING_STD(set);
-SG_USING_STD(vector);
+using std::string;
+using std::map;
+using std::set;
+using std::vector;
#include <string>
#include <vector>
-SG_USING_STD(string);
-SG_USING_STD(vector);
+using std::string;
+using std::vector;
#include <simgear/props/props.hxx>
#include <simgear/route/route.hxx>
#include <vector>
#include <deque>
-SG_USING_STD(string);
-SG_USING_STD(vector);
-SG_USING_STD(deque);
+using std::string;
+using std::vector;
+using std::deque;
#include <simgear/props/props.hxx>
#include <simgear/structure/subsystem_mgr.hxx>
#include <simgear/constants.h>
#include <simgear/debug/logstream.hxx>
#include <simgear/misc/sg_path.hxx>
+#include <osg/GLU>
#include <Aircraft/aircraft.hxx>
//#include <Autopilot/xmlauto.hxx>
#include "hud.hxx"
-#include SG_GLU_H
-
static HUD_Properties *HUDprop = 0;
#include <plib/sg.h>
-SG_USING_STD(deque);
-SG_USING_STD(vector);
+using std::deque;
+using std::vector;
#define float_to_int(v) SGMiscf::roundToInt(v)
#include <simgear/math/polar3d.hxx>
#include <ATCDCL/ATCutils.hxx>
-#include SG_GLU_H
+#include <osg/GLU>
// int x, int y, int width, int height, float scale_data, bool working)
#include <simgear/debug/logstream.hxx>
#include <simgear/misc/sg_path.hxx>
#include <simgear/scene/model/model.hxx>
+#include <osg/GLU>
#include <Main/globals.hxx>
#include <Main/fg_props.hxx>
#include "hud.hxx"
#include "panel.hxx"
-#include SG_GLU_H
-
#define WIN_X 0
#define WIN_Y 0
#define WIN_W 1024
#include <Input/input.hxx>
#include <Instrumentation/dclgps.hxx>
-SG_USING_STD(vector);
-SG_USING_STD(map);
+using std::vector;
+using std::map;
class FGPanelInstrument;
//built-in layers
#include "built_in/FGMagRibbon.hxx"
-SG_USING_STD(istream);
-SG_USING_STD(ifstream);
-SG_USING_STD(string);
+using std::istream;
+using std::ifstream;
+using std::string;
\f
#include "environment_mgr.hxx"
#include "environment_ctrl.hxx"
-SG_USING_STD(sort);
+using std::sort;
class metar_filter : public FGAirportSearchFilter {
virtual bool pass(FGAirport *a) { return a->getMetar(); }
#include <queue>
#include <vector>
-SG_USING_STD(queue);
-SG_USING_STD(vector);
+using std::queue;
+using std::vector;
class SGPropertyNode;
class FGAirport;
#include <string>
-SG_USING_STD(string);
+using std::string;
class SGNewCloud;
class SGCloudField;
#include <simgear/environment/metar.hxx>
-SG_USING_STD(vector);
-SG_USING_STD(map);
-SG_USING_STD(string);
+using std::vector;
+using std::map;
+using std::string;
class FGMetar : public SGMetar {
#include "LaRCsimIC.hxx"
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cout;
+using std::endl;
LaRCsimIC::LaRCsimIC(void) {
#include "uiuc_aircraft.h"
#include "uiuc_warnings_errors.h"
-//SG_USING_STD(istrstream);
+//using std::istrstream;
int uiuc_1DdataFileReader( string file_name,
double x[],
#include "uiuc_parsefile.h"
#include "uiuc_aircraft.h"
-//SG_USING_STD(istrstream);
+//using std::istrstream;
void uiuc_2DdataFileReader( string file_name,
double x[100][100],
#include "uiuc_warnings_errors.h"
//#include "uiuc_aircraft.h"
-SG_USING_STD(ifstream);
-SG_USING_STD(istringstream);
+using std::ifstream;
+using std::istringstream;
class flapStruct {
private:
-SG_USING_STD(cerr);
+using std::cerr;
#define HEIGHT_AGL_WHEEL d_wheel_rwy_local_v[2]
#include "uiuc_menu.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void uiuc_menu( string aircraft_name )
#include "uiuc_menu_CD.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_CD( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_CL.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_CL( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_CY.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_CY( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_Cm.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_Cm( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_Cn.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_Cn( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_Croll.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_Cl( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_controlSurface.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_controlSurface( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_engine.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_engine( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_fog.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_fog( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_gear.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_gear( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_geometry.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_geometry( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_ice.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_ice( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_init.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_init( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_mass.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_mass( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_misc.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_misc( const string& linetoken2, const string& linetoken3,
#include "uiuc_menu_record.h"
-SG_USING_STD(cerr);
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cerr;
+using std::cout;
+using std::endl;
#ifndef _MSC_VER
-SG_USING_STD(exit);
+using std::exit;
#endif
void parse_record( const string& linetoken2, const string& linetoken3,
#include <list>
#include <fstream>
-SG_USING_STD(list);
-SG_USING_STD(string);
-SG_USING_STD(getline);
-SG_USING_STD(ifstream);
+using std::list;
+using std::string;
+using std::getline;
+using std::ifstream;
#define DELIMITERS " \t"
#define COMMENT "#"
#include "uiuc_recorder.h"
-SG_USING_STD(endl); // -dw
+using std::endl; // -dw
void uiuc_recorder( double dt )
{
//#include "uiuc_network.h"
#include "uiuc_get_flapper.h"
-SG_USING_STD(cout);
-SG_USING_STD(endl);
+using std::cout;
+using std::endl;
extern "C" void uiuc_initial_init ();
extern "C" void uiuc_defaults_inits ();
#include <iostream>
#include <iomanip>
-SG_USING_STD(setprecision);
+using std::setprecision;
#ifdef TEST_DEBUG
#include <stdio.h>
#include <simgear/structure/subsystem_mgr.hxx>
#include <FDM/groundcache.hxx>
-SG_USING_STD(list);
-SG_USING_STD(vector);
-SG_USING_STD(string);
+using std::list;
+using std::vector;
+using std::string;
// This is based heavily on LaRCsim/ls_generic.h
class FGInterface : public SGSubsystem {
#include <simgear/misc/sg_path.hxx>
#include <vector>
-SG_USING_STD(vector);
+using std::vector;
// ugly temporary workaround for plib's lack of user defined class ids FIXME
#include <iostream>
#include <simgear/compiler.h>
-#include SG_GL_H
+#include <osg/GL>
#include <plib/pw.h>
#include <plib/pu.h>
#include <simgear/props/props.hxx>
#include <plib/pu.h>
#include <map>
-SG_USING_STD(map);
+using std::map;
#include <vector>
-SG_USING_STD(vector);
+using std::vector;
class puMenuBar;
#include <vector>
#include <map>
-SG_USING_STD(vector);
-SG_USING_STD(map);
-SG_USING_STD(string);
+using std::vector;
+using std::map;
+using std::string;
#include <Main/fg_props.hxx>
#include <iomanip>
#include <iostream>
#include <string>
-SG_USING_STD(string);
+using std::string;
using std::cout;
typedef string stdString; // puObject has a "string" member
#include <fstream>
#include <string>
-SG_USING_STD(fstream);
-SG_USING_STD(cout);
-SG_USING_STD(cin);
-SG_USING_STD(endl);
-SG_USING_STD(ios);
-SG_USING_STD(string);
+using std::fstream;
+using std::cout;
+using std::cin;
+using std::endl;
+using std::ios;
+using std::string;
#include <simgear/constants.h>
#include <simgear/debug/logstream.hxx>
#include <Scenery/scenery.hxx>
#include <Main/renderer.hxx>
-SG_USING_STD(ifstream);
-SG_USING_STD(ostringstream);
-SG_USING_STD(string);
-SG_USING_STD(vector);
+using std::ifstream;
+using std::ostringstream;
+using std::string;
+using std::vector;
void mouseClickHandler(int button, int updown, int x, int y, bool mainWindow, const osgGA::GUIEventAdapter*);
void mouseMotionHandler(int x, int y);
#include <list>
#include <vector>
-SG_USING_STD(map);
-SG_USING_STD(vector);
+using std::map;
+using std::vector;
\f
#include <iostream>
-SG_USING_STD(cout);
-SG_USING_STD(cin);
-SG_USING_STD(endl);
+using std::cout;
+using std::cin;
+using std::endl;
#include "jsinput.h"
#include <simgear/constants.h>
#include <simgear/misc/sg_path.hxx>
+#include <osg/GLU>
#include <Main/globals.hxx>
#include <Main/viewmgr.hxx>
#include "HUD.hxx"
-#include SG_GLU_H
-
static float clamp(float f)
{
#include <deque>
#include <fstream>
-SG_USING_STD(deque);
-SG_USING_STD(vector);
+using std::deque;
+using std::vector;
#include <osg/State>
#include <simgear/compiler.h>
#include <simgear/math/sg_geodesy.hxx>
#include <simgear/math/polar3d.hxx>
-#include SG_GLU_H
+#include <osg/GLU>
#include <Main/globals.hxx>
#include <Scenery/scenery.hxx>
#include <Main/fg_props.hxx>
#include <simgear/math/point3d.hxx>
-SG_USING_STD(cout);
+using std::cout;
KLN89::KLN89(RenderArea2D* instrument)
: DCLGPS(instrument) {
#include <simgear/structure/subsystem_mgr.hxx>
#include <Sound/morse.hxx>
-SG_USING_STD(string);
+using std::string;
/**
#include <simgear/structure/commands.hxx>
#include <Main/fg_props.hxx>
#include <iostream>
-SG_USING_STD(cout);
+using std::cout;
//using namespace std;
#include "gps.hxx"
-SG_USING_STD(string);
+using std::string;
GPS::GPS ( SGPropertyNode *node)
#include "kr_87.hxx"
#include <string>
-SG_USING_STD(string);
+using std::string;
static int play_count = 0;
static time_t last_time = 0;
#include "marker_beacon.hxx"
#include <string>
-SG_USING_STD(string);
+using std::string;
// Constructor
#include <simgear/sound/soundmgr_openal.hxx>
#include <simgear/structure/exception.hxx>
-SG_USING_STD(string);
+using std::string;
#include "Airports/runways.hxx"
#include "Airports/simple.hxx"
#include <simgear/sound/sample_openal.hxx>
#include <simgear/structure/subsystem_mgr.hxx>
-SG_USING_STD(vector);
-SG_USING_STD(deque);
-SG_USING_STD(map);
+using std::vector;
+using std::deque;
+using std::map;
#include "Airports/runways.hxx"
#include "Airports/simple.hxx"
#include "navradio.hxx"
#include <string>
-SG_USING_STD(string);
+using std::string;
// Constructor
#include "render_area_2d.hxx"
-
static const float dummy_normals[][3] = {{0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f},
{0.0f, 0.0f, 0.0f},
#include <vector>
-SG_USING_STD(vector);
+using std::vector;
enum RA2DDrawingType {
RA2D_LINE,
#include "tacan.hxx"
-SG_USING_STD(vector);
+using std::vector;
/**
#include <sstream>
#include <iomanip>
-SG_USING_STD(stringstream);
-SG_USING_STD(endl);
-SG_USING_STD(setprecision);
-SG_USING_STD(fixed);
-SG_USING_STD(setw);
-SG_USING_STD(setfill);
+using std::stringstream;
+using std::endl;
+using std::setprecision;
+using std::fixed;
+using std::setw;
+using std::setfill;
#include <Main/fg_props.hxx>
#include <Main/globals.hxx>
#include <AIModel/AIManager.hxx>
#include <vector>
#include <string>
-SG_USING_STD(vector);
-SG_USING_STD(string);
+using std::vector;
+using std::string;
class FGAIBase;
class FGODGauge;
#include <simgear/debug/logstream.hxx>
#include <iostream>
-SG_USING_STD(cerr);
-SG_USING_STD(endl);
+using std::cerr;
+using std::endl;
#include "main.hxx"
#include "globals.hxx"
#include "viewmgr.hxx"
#include "main.hxx"
-SG_USING_STD(string);
-SG_USING_STD(ifstream);
-SG_USING_STD(ofstream);
+using std::string;
+using std::ifstream;
+using std::ofstream;
\f
#include "viewmgr.hxx"
#include "main.hxx"
-SG_USING_STD(string);
+#ifdef __APPLE__
+# include <CoreFoundation/CoreFoundation.h>
+#endif
+using std::string;
class Sound;
extern const char *default_root;
#include <Airports/simple.hxx>
-SG_USING_STD(string);
+using std::string;
// Read in configuration (files and command line optoins) but only set
#include "globals.hxx"
#include "fg_io.hxx"
-SG_USING_STD(string);
+using std::string;
FGIO::FGIO()
}
#include <algorithm>
-SG_USING_STD(for_each);
+using std::for_each;
static void delete_ptr( FGProtocol* p ) { delete p; }
#include <vector>
#include <string>
-SG_USING_STD(vector);
-SG_USING_STD(string);
+using std::vector;
+using std::string;
class FGProtocol;
#include <simgear/compiler.h>
-#include SG_GLUT_H
-
+#if defined( __APPLE__)
+# include <GLUT/glut.h>
+#else
+# include <GL/glut.h>
+#endif
#include <plib/pu.h>
#include <Scenery/scenery.hxx>
#include "globals.hxx"
#include "fg_props.hxx"
-SG_USING_STD(istream);
-SG_USING_STD(ostream);
+using std::istream;
+using std::ostream;
static bool winding_ccw = true; // FIXME: temporary
#include <fstream>
#include <string>
-SG_USING_STD(ofstream);
-SG_USING_STD(endl);
-SG_USING_STD(string);
+using std::ofstream;
+using std::endl;
+using std::string;
#include <simgear/debug/logstream.hxx>
#include "viewmgr.hxx"
-SG_USING_STD(string);
-SG_USING_STD(sort);
+using std::string;
+using std::sort;
#ifndef VERSION
#define VERSION "CVS "__DATE__
#include <cstdlib>
#include <vector>
-SG_USING_STD(vector);
+using std::vector;
#include <simgear/debug/logstream.hxx>
#include "fg_props.hxx"
#include "viewer.hxx"
-SG_USING_STD(vector);
+using std::vector;
// Define a structure containing view information
#include <vector>
#include <string>
-SG_USING_STD(string);
-SG_USING_STD(vector);
+using std::string;
+using std::vector;
#include <osg/ref_ptr>
#include <osg/Group>
#include "model_panel.hxx"
-SG_USING_STD(vector);
+using std::vector;
using namespace simgear;
#include <vector>
-SG_USING_STD(vector);
+using std::vector;
#include <simgear/math/point3d.hxx>
#include <simgear/props/props.hxx>
#include "modelmgr.hxx"
-SG_USING_STD(vector);
+using std::vector;
using namespace simgear;
#include <simgear/compiler.h> // for SG_USING_STD
#include <simgear/structure/subsystem_mgr.hxx>
-SG_USING_STD(vector);
+using std::vector;
// Don't pull in headers, since we don't need them here.
class SGPropertyNode;
#include <Cockpit/panel_io.hxx>
#include "panelnode.hxx"
-SG_USING_STD(vector);
+using std::vector;
// Static (!) handling for all 3D panels in the program.
#endif
#include <string>
-SG_USING_STD(string);
+using std::string;
#include <vector>
-SG_USING_STD(vector);
+using std::vector;
#include <simgear/compiler.h>
#include <simgear/props/props.hxx>
#include "awynet.hxx"
-SG_USING_STD(sort);
+using std::sort;
using std::cerr;
using std::endl;
#include <string>
-// SG_USING_STD(cout);
-// SG_USING_STD(endl);
+// using std::cout;
+// using std::endl;
class FGFix {
#include <simgear/math/sg_geodesy.hxx>
#include "fixlist.hxx"
-SG_USING_STD(pair);
+using std::pair;
// Constructor
#include "fix.hxx"
-SG_USING_STD(multimap);
-SG_USING_STD(vector);
-SG_USING_STD(string);
+using std::multimap;
+using std::vector;
+using std::string;
// fix names may be globally non-unique. Allow for this.
typedef multimap < string, FGFix > fix_map_type;
#include "navlist.hxx"
#include "fixlist.hxx"
-// SG_USING_STD(map);
-// SG_USING_STD(vector);
-// SG_USING_STD(string);
+// using std::map;
+// using std::vector;
+// using std::string;
// load and initialize the navigational databases
#include "navrecord.hxx"
-SG_USING_STD(map);
-SG_USING_STD(vector);
-SG_USING_STD(string);
+using std::map;
+using std::vector;
+using std::string;
#include "ATC-Inputs.hxx"
-SG_USING_STD(string);
+using std::string;
#include "ATC-Main.hxx"
-SG_USING_STD(string);
+using std::string;
// Lock the ATC hardware
#include "ATC-Outputs.hxx"
-SG_USING_STD(string);
+using std::string;
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
class FGAV400 : public FGProtocol {
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
class FGAtlas : public FGProtocol {
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
class FGGarmin : public FGProtocol {
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
class FGGeneric : public FGProtocol {
#include "httpd.hxx"
-SG_USING_STD(string);
+using std::string;
bool FGHttpd::open() {
if ( is_enabled() ) {
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
class FGJoyClient : public FGProtocol {
#include <osgUtil/SceneView>
extern osg::ref_ptr<osgUtil::SceneView> sceneView;
-SG_USING_STD(string);
+using std::string;
bool FGJpegHttpd::open() {
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
class FGJsClient : public FGProtocol {
#include <Main/globals.hxx>
#include <Main/fg_props.hxx>
-SG_USING_STD(vector);
+using std::vector;
FGLFSGlass::FGLFSGlass() :
press_node(fgGetNode("/environment/pressure-inhg[0]", true)),
#include "multiplay.hxx"
-SG_USING_STD(string);
+using std::string;
// These constants are provided so that the ident command can list file versions.
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
/****************************************************************
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
class FGNative : public FGProtocol {
#include "protocol.hxx"
#include "net_ctrls.hxx"
-SG_USING_STD(string);
+using std::string;
class FGNativeCtrls : public FGProtocol {
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
class FGNMEA : public FGProtocol {
#include <Main/globals.hxx>
#include <Main/fg_props.hxx>
-SG_USING_STD(vector);
+using std::vector;
FGOpenGC::FGOpenGC() :
press_node(fgGetNode("/environment/pressure-inhg[0]", true)),
#include "props.hxx"
-SG_USING_STD(stringstream);
-SG_USING_STD(ends);
+using std::stringstream;
+using std::ends;
using std::cout;
using std::endl;
#include <string>
#include <vector>
-SG_USING_STD(string);
-SG_USING_STD(vector);
+using std::string;
+using std::vector;
#include <plib/netChannel.h>
#include <string>
#include <vector>
-SG_USING_STD(string);
-SG_USING_STD(vector);
+using std::string;
+using std::vector;
#define FG_MAX_MSG_SIZE 16384
typedef io_container::const_iterator const_io_iterator;
#include <stdexcept>
-SG_USING_STD(invalid_argument);
+using std::invalid_argument;
//namespace flightgear { namespace network {
class FGProtocolConfigError : public invalid_argument
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
class FGPVE : public FGProtocol {
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
class FGRAY : public FGProtocol {
#include "protocol.hxx"
-SG_USING_STD(string);
+using std::string;
class FGRUL : public FGProtocol {
#include <simgear/xml/easyxml.hxx>
#include <map>
-SG_USING_STD(map);
+using std::map;
class FGNasalScript;
#include <simgear/sound/sample_openal.hxx>
#include <simgear/structure/subsystem_mgr.hxx>
-SG_USING_STD(queue);
-SG_USING_STD(vector);
+using std::queue;
+using std::vector;
class SGXmlSound;
# include <simgear/threads/SGQueue.hxx>
#else
# include <queue>
- SG_USING_STD(queue);
+ using std::queue;
#endif // ENABLE_THREADS
-SG_USING_STD(vector);
+using std::vector;
#include <string>
#include <vector>
-SG_USING_STD(string);
-SG_USING_STD(vector);
+using std::string;
+using std::vector;
#include <simgear/props/props.hxx>
#include <simgear/structure/subsystem_mgr.hxx>
#include <simgear/compiler.h>
#include <string>
-SG_USING_STD(string);
+using std::string;
#include <simgear/props/props.hxx>
#include <simgear/structure/subsystem_mgr.hxx>
using namespace std;
-SG_USING_STD(vector);
+using std::vector;
class FGScheduledFlight
#include "TrafficMgr.hxx"
-SG_USING_STD(sort);
+using std::sort;
/******************************************************************************
* TrafficManager
#include <stdio.h>
#include <simgear/compiler.h>
-
-#include SG_GLUT_H
-
+#if defined( __APPLE__)
+# include <OpenGL/OpenGL.h>
+#else
+# include <GL/gl.h>
+#endif
int main() {
GLfloat a, t;
#include <stdlib.h>
#include <simgear/compiler.h>
-
-#include SG_GLUT_H
+#if defined( __APPLE__)
+# include <OpenGL/OpenGL.h>
+# include <GLUT/glut.h>
+#else
+# include <GL/gl.h>
+# include <GL/glut.h>
+#endif
void getPrints ( GLenum token, char *string )
#include <math.h>
#include <simgear/compiler.h>
-
-#include SG_GLUT_H
+#if defined( __APPLE__)
+# include <OpenGL/OpenGL.h>
+# include <GLUT/glut.h>
+#else
+# include <GL/gl.h>
+# include <GL/glut.h>
+#endif
#define TEXRES_X 256
#define TEXRES_Y 256
#include <string.h>
#include <stdlib.h>
-#include SG_GL_H
+#include <osg/GL>
#include <simgear/screen/texture.hxx>