//Initialization
fresult TextForm::Init(TextField* textFields, int controlsCount, Size* size, IRender *pRender)
{
fresult result = SUCCESS;
_pControls = textFields;
_controlsCount = controlsCount;
_Size = *size;
_pRender = pRender;
result = RegisterControls();
return result;
}
void
FormWindow::Init(const FormDef& def)
{
if (def.GetRect().w > 0 && def.GetRect().h > 0) {
// if form size is specified in def, and it is
// smaller than the current screen size,
// center the form on the display:
Rect r = def.GetRect();
if (r.w < screen->Width()) {
r.x = (screen->Width() - r.w) / 2;
}
else {
r.x = 0;
r.w = screen->Width();
}
if (r.h < screen->Height()) {
r.y = (screen->Height() - r.h) / 2;
}
else {
r.y = 0;
r.h = screen->Height();
}
MoveTo(r);
}
SetMargins(def.GetMargins());
SetTextInsets(def.GetTextInsets());
SetCellInsets(def.GetCellInsets());
SetCells(def.GetCells());
SetFixedWidth(def.GetFixedWidth());
SetFixedHeight(def.GetFixedHeight());
UseLayout(def.GetLayout().x_mins,
def.GetLayout().y_mins,
def.GetLayout().x_weights,
def.GetLayout().y_weights);
if (def.GetTexture().length() > 0) {
DataLoader* loader = DataLoader::GetLoader();
loader->SetDataPath("Screens/");
loader->LoadTexture(def.GetTexture(), texture);
loader->SetDataPath("");
}
SetBackColor(def.GetBackColor());
SetForeColor(def.GetForeColor());
Font* f = FontMgr::Find(def.GetFont());
if (f) SetFont(f);
SetTransparent(def.GetTransparent());
ListIter<CtrlDef> ctrl = def.GetControls();
while (++ctrl) {
switch (ctrl->GetType()) {
case WIN_DEF_FORM:
case WIN_DEF_LABEL:
default:
CreateDefLabel(*ctrl);
break;
case WIN_DEF_BUTTON:
CreateDefButton(*ctrl);
break;
case WIN_DEF_COMBO:
CreateDefCombo(*ctrl);
break;
case WIN_DEF_IMAGE:
CreateDefImage(*ctrl);
break;
case WIN_DEF_EDIT:
CreateDefEdit(*ctrl);
break;
case WIN_DEF_LIST:
CreateDefList(*ctrl);
break;
case WIN_DEF_SLIDER:
CreateDefSlider(*ctrl);
break;
case WIN_DEF_RICH:
CreateDefRichText(*ctrl);
break;
}
}
RegisterControls();
DoLayout();
CalcGrid();
}
bool GuiPage::Load(
const std::string & path,
const std::string & texpath,
const float hwratio,
const GuiLanguage & lang,
const Font & font,
const StrSignalMap & vsignalmap,
const StrVecSlotMap & vnactionmap,
const StrSlotMap & vactionmap,
IntSlotMap nactionmap,
SlotMap actionmap,
ContentManager & content,
std::ostream & error_output)
{
Clear();
Config pagefile;
if (!pagefile.load(path))
{
error_output << "Couldn't find GUI page file: " << path << std::endl;
return false;
}
if (!pagefile.get("", "name", name, error_output))
return false;
//error_output << "Loading " << path << std::endl;
// load widgets and controls
active_control = 0;
std::map<std::string, GuiWidget*> widgetmap; // labels, images, sliders
std::map<std::string, GuiWidgetList*> widgetlistmap; // labels, images lists
std::vector<Config::const_iterator> controlit; // control iterator cache
std::vector<Config::const_iterator> controlnit; // control list iterator cache
std::vector<GuiControlList*> controllists; // control list cache
for (Config::const_iterator section = pagefile.begin(); section != pagefile.end(); ++section)
{
if (section->first.empty()) continue;
Rect r = LoadRect(pagefile, section, hwratio);
float x0 = r.x - r.w * 0.5;
float y0 = r.y - r.h * 0.5;
float x1 = r.x + r.w * 0.5;
float y1 = r.y + r.h * 0.5;
GuiWidget * widget = 0;
// load widget(list)
std::string value;
if (pagefile.get(section, "text", value))
{
std::string alignstr;
float fontsize = 0.03;
pagefile.get(section, "fontsize", fontsize);
pagefile.get(section, "align", alignstr);
int align = 0;
if (alignstr == "right") align = 1;
else if (alignstr == "left") align = -1;
float scaley = fontsize;
float scalex = fontsize * hwratio;
GuiLabelList * widget_list = 0;
if (LoadList(pagefile, section, x0, y0, x1, y1, hwratio, widget_list))
{
// connect with the value list
StrVecSlotMap::const_iterator vni = vnactionmap.find(value);
if (vni != vnactionmap.end())
{
StrSignalMap::const_iterator vsi = vsignalmap.find(value + ".update");
if (vsi != vsignalmap.end())
{
widget_list->update_list.connect(*vsi->second);
vni->second->connect(widget_list->get_values);
}
}
// init drawable
widget_list->SetupDrawable(node, font, align, scalex, scaley, r.z);
widgetlistmap[section->first] = widget_list;
widget = widget_list;
}
else
{
// none is reserved for empty text string
if (value == "none")
value.clear();
else
value = lang(value);
GuiLabel * new_widget = new GuiLabel();
new_widget->SetupDrawable(
node, font, align, scalex, scaley,
r.x, r.y, r.w, r.h, r.z);
ConnectAction(value, vsignalmap, new_widget->set_value);
std::string name;
if (pagefile.get(section, "name", name))
labels[name] = new_widget;
widgetmap[section->first] = new_widget;
widget = new_widget;
}
}
else if (pagefile.get(section, "image", value))
{
std::string slider, ext, path = texpath;
pagefile.get(section, "path", path);
pagefile.get(section, "ext", ext);
GuiImageList * widget_list = 0;
if (LoadList(pagefile, section, x0, y0, x1, y1, hwratio, widget_list))
{
// init drawable
widget_list->SetupDrawable(node, content, path, ext, r.z);
// connect with the value list
StrVecSlotMap::const_iterator vni = vnactionmap.find(value);
if (vni != vnactionmap.end())
{
StrSignalMap::const_iterator vsi = vsignalmap.find(value + ".update");
if (vsi != vsignalmap.end())
{
widget_list->update_list.connect(*vsi->second);
vni->second->connect(widget_list->get_values);
}
}
else
{
// special case of list containing the same image?
widget_list->SetImage(value);
}
widgetlistmap[section->first] = widget_list;
widget = widget_list;
}
else if (pagefile.get(section, "slider", slider))
{
bool fill = false;
pagefile.get(section, "fill", fill);
TextureInfo texinfo;
texinfo.mipmap = false;
texinfo.repeatu = false;
texinfo.repeatv = false;
std::tr1::shared_ptr<Texture> tex;
content.load(tex, texpath, value, texinfo);
float radius = 0.0;
if (pagefile.get(section, "radius", radius))
{
float start_angle(0), end_angle(2 * M_PI);
pagefile.get(section, "start-angle", start_angle);
pagefile.get(section, "end-angle", end_angle);
GuiRadialSlider * new_widget = new GuiRadialSlider();
new_widget->SetupDrawable(
node, tex,
r.x, r.y, r.w, r.h, r.z,
start_angle, end_angle, radius,
hwratio, fill, error_output);
ConnectAction(slider, vsignalmap, new_widget->set_value);
widget = new_widget;
}
else
{
GuiSlider * new_widget = new GuiSlider();
new_widget->SetupDrawable(
node, tex,
r.x, r.y, r.w, r.h, r.z,
fill, error_output);
ConnectAction(slider, vsignalmap, new_widget->set_value);
widget = new_widget;
}
widgetmap[section->first] = widget;
}
else
{
GuiImage * new_widget = new GuiImage();
new_widget->SetupDrawable(
node, content, path, ext,
r.x, r.y, r.w, r.h, r.z);
ConnectAction(value, vsignalmap, new_widget->set_image);
widgetmap[section->first] = new_widget;
widget = new_widget;
}
}
// set widget properties (connect property slots)
if (widget)
{
std::string val;
if (pagefile.get(section, "visible", val))
ConnectAction(val, vsignalmap, widget->set_visible);
if (pagefile.get(section, "opacity", val))
ConnectAction(val, vsignalmap, widget->set_opacity);
if (pagefile.get(section, "color", val))
ConnectAction(val, vsignalmap, widget->set_color);
if (pagefile.get(section, "hue", val))
ConnectAction(val, vsignalmap, widget->set_hue);
if (pagefile.get(section, "sat", val))
ConnectAction(val, vsignalmap, widget->set_sat);
if (pagefile.get(section, "val", val))
ConnectAction(val, vsignalmap, widget->set_val);
widgets.push_back(widget);
}
// load controls
bool focus;
if (pagefile.get(section, "focus", focus))
{
GuiControl * control = 0;
GuiControlList * control_list = 0;
if (LoadList(pagefile, section, x0, y0, x1, y1, hwratio, control_list))
{
// register control list scroll actions
actionmap[section->first + ".scrollf"] = &control_list->scroll_fwd;
actionmap[section->first + ".scrollr"] = &control_list->scroll_rev;
// connect with item list
if (pagefile.get(section, "list", value))
{
StrSignalMap::const_iterator vsu = vsignalmap.find(value + ".update");
StrSignalMap::const_iterator vsn = vsignalmap.find(value + ".nth");
if (vsu != vsignalmap.end() && vsn != vsignalmap.end())
{
control_list->update_list.connect(*vsu->second);
control_list->set_nth.connect(*vsn->second);
}
else
{
error_output << value << " is not a list." << std::endl;
}
}
control = control_list;
controlnit.push_back(section);
controllists.push_back(control_list);
}
else
{
control = new GuiControl();
controlit.push_back(section);
controls.push_back(control);
}
control->SetRect(x0, y0, x1, y1);
if (focus)
active_control = control;
}
}
// load control actions (connect control signals)
// parse control event actions with values(arguments)
typedef std::pair<std::string, Slot2<int, const std::string &>*> ActionValn;
typedef std::pair<std::string, Slot1<const std::string &>*> ActionVal;
std::set<ActionValn> action_valn_set;
std::set<ActionVal> action_val_set;
std::string actionstr;
for (size_t i = 0; i < controlit.size(); ++i)
{
for (size_t j = 0; j < GuiControl::signal_names.size(); ++j)
{
if (pagefile.get(controlit[i], GuiControl::signal_names[j], actionstr))
ParseActions(actionstr, vactionmap, widgetmap, widgetlistmap,
action_val_set, action_valn_set);
}
}
for (size_t i = 0; i < controlnit.size(); ++i)
{
for (size_t j = 0; j < GuiControl::signal_names.size(); ++j)
{
if (pagefile.get(controlnit[i], GuiControl::signal_names[j], actionstr))
ParseActions(actionstr, vactionmap, widgetmap, widgetlistmap,
action_val_set, action_valn_set);
}
}
// parse page event actions with values
if (pagefile.get("", "onfocus", actionstr))
ParseActions(actionstr, vactionmap, widgetmap, widgetlistmap,
action_val_set, action_valn_set);
if (pagefile.get("", "oncancel", actionstr))
ParseActions(actionstr, vactionmap, widgetmap, widgetlistmap,
action_val_set, action_valn_set);
// register controls, so that they can be activated by control events
control_set.reserve(controlit.size() + controlnit.size());
RegisterControls(controlit, controls, this, control_set, actionmap);
RegisterControls(controlnit, controllists, this, control_set, actionmap);
// register action calls with a parameter, so that they can be signaled by controls
RegisterActions(lang, action_val_set, action_set, actionmap);
RegisterActions(lang, action_valn_set, action_setn, nactionmap);
// connect control signals with their actions
for (size_t i = 0; i < controlit.size(); ++i)
{
for (size_t j = 0; j < GuiControl::EVENTNUM; ++j)
{
if (pagefile.get(controlit[i], GuiControl::signal_names[j], actionstr))
ConnectActions(actionstr, actionmap, controls[i]->m_signal[j]);
}
for (size_t j = 0; j < GuiControl::EVENTVNUM; ++j)
{
if (pagefile.get(controlit[i], GuiControl::signal_names[GuiControl::EVENTNUM + j], actionstr))
ConnectActions(actionstr, vactionmap, controls[i]->m_signalv[j]);
}
}
for (size_t i = 0; i < controlnit.size(); ++i)
{
for (size_t j = 0; j < GuiControl::EVENTNUM; ++j)
{
if (pagefile.get(controlnit[i], GuiControl::signal_names[j], actionstr))
{
ConnectActions(actionstr, actionmap, controllists[i]->m_signal[j]);
ConnectActions(actionstr, nactionmap, controllists[i]->m_signaln[j]);
}
}
}
// connect page event signals with their actions
if (pagefile.get("", "onfocus", actionstr))
ConnectActions(actionstr, actionmap, onfocus);
if (pagefile.get("", "oncancel", actionstr))
ConnectActions(actionstr, actionmap, oncancel);
controls.insert(controls.end(), controllists.begin(), controllists.end());
// set active control
if (!active_control && !controls.empty())
active_control = controls[0];
// enable active control
if (active_control)
active_control->Signal(GuiControl::FOCUS);
// set default control
default_control = active_control;
return true;
}
MsnEditNavDlg::MsnEditNavDlg(Screen* s, FormDef& def, MenuScreen* mgr)
: NavDlg(s, def, mgr), menu_screen(mgr), mission_info(0),
btn_accept(0), btn_cancel(0), btn_sit(0), btn_pkg(0), btn_map(0)
{
RegisterControls();
}
extern int main ( int argc, char *argv[] ) {
/**************************************************************************
* Register self. *
**************************************************************************/
Sys_RegisterThread ( ) ;
/**************************************************************************
* Set a default exception filter. *
**************************************************************************/
REGISTER_EXCEPTION_HANDLER(0);
/**************************************************************************
* Start the main block (for constructors/destructors). *
**************************************************************************/
{
/**************************************************************************
* Get the initial file path for loading files from command-line. *
**************************************************************************/
char InitialPath [CCHMAXPATH] ;
_fullpath ( InitialPath, ".", sizeof(InitialPath) ) ;
strcat ( InitialPath, "\\" ) ;
/**************************************************************************
* Determine the home directory. *
**************************************************************************/
char Drive [_MAX_DRIVE+1], Dir[_MAX_DIR+1], Fname[_MAX_FNAME+1], Ext[_MAX_EXT+1] ;
strupr ( argv[0] ) ;
_fullpath ( HomePath, argv[0], sizeof(HomePath) ) ;
_splitpath ( HomePath, Drive, Dir, Fname, Ext ) ;
if ( Dir[strlen(Dir)-1] == '\\' )
Dir[strlen(Dir)-1] = 0 ;
strcpy ( HomePath, Drive ) ;
strcat ( HomePath, Dir ) ;
_chdrive ( Drive[0] - 'A' + 1 ) ;
_chdir ( "\\" ) ;
_chdir ( Dir ) ;
/**************************************************************************
* Set the C RunTime Library error message file handle. *
**************************************************************************/
#ifdef __DEBUG_ALLOC__
Log ( "Escriba::main: Program started." ) ;
_set_crt_msg_handle ( fileno(Logfile) ) ;
#else
#ifdef DEBUG
Log ( "Escriba::main: Program started." ) ;
#endif // DEBUG
#endif // __DEBUG_ALLOC__
/**************************************************************************
* Determine if another instance of this program is present. *
* If so, pass the command-line information to it. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Checking for another instance already loaded." ) ;
#endif // DEBUG
PublicMemory Memory ( MEMORY_NAME, sizeof(SHARED_MEMORY), TRUE ) ;
if ( NOT Memory.QueryCreated() ) {
// Get the main instance's window handle. Wait up to 20 seconds if necessary.
HWND MainWindow = ((SHARED_MEMORY*)Memory.QueryMemory())->MainWindow ;
clock_t LastClock = clock ( ) ;
while ( MainWindow == 0 ) {
if ( ( ( clock() - LastClock ) / CLOCKS_PER_SEC ) > 20 ) {
Log ( "ERROR: Unable to get previous instance window handle." ) ;
return ( 1 ) ;
} /* endif */
DosSleep ( 100 ) ;
MainWindow = ((SHARED_MEMORY*)Memory.QueryMemory())->MainWindow ;
} /* endwhile */
// If any command-line parameters were given . . .
if ( argc > 1 ) {
// Build a command-line string.
char Parms [512] = { 0 } ;
int ParmLength = 0 ;
while ( --argc ) {
strcpy ( Parms+ParmLength, *(++argv) ) ;
ParmLength += strlen(*argv) + 1 ;
} /* endwhile */
Parms[++ParmLength] = 0 ;
// Get the original process's ID.
PID Process ;
TID Thread ;
if ( !WinQueryWindowProcess ( MainWindow, &Process, &Thread ) ) {
char Message [512] ;
Log ( "ERROR: Unable to query window process. %s", InterpretWinError(0,Message) ) ;
return ( 1 ) ;
} /* endif */
// Allocate shared memory to hold the current path.
PVOID Memory1 ;
APIRET Status = DosAllocSharedMem ( &Memory1, 0, strlen(InitialPath)+1, fALLOC | OBJ_GIVEABLE | OBJ_GETTABLE) ;
if ( Status ) {
Log ( "ERROR: Unable to allocate shared memory. Status %d.", Status ) ;
return ( 1 ) ;
} /* endif */
strcpy ( PCHAR(Memory1), InitialPath ) ;
// Allocate shared memory to hold the command-line.
PVOID Memory2 ;
Status = DosAllocSharedMem ( &Memory2, 0, ParmLength, fALLOC | OBJ_GIVEABLE | OBJ_GETTABLE) ;
if ( Status ) {
Log ( "ERROR: Unable to allocate shared memory. Status %d.", Status ) ;
return ( 1 ) ;
} /* endif */
memcpy ( Memory2, Parms, ParmLength ) ;
// Make both shared memory blocks available to the original process.
Status = DosGiveSharedMem ( Memory1, Process, PAG_READ | PAG_WRITE ) ;
DosFreeMem ( Memory1 ) ;
if ( Status ) {
Log ( "ERROR: Unable to give shared memory. Status %d.", Status ) ;
return ( 1 ) ;
} /* endif */
Status = DosGiveSharedMem ( Memory2, Process, PAG_READ | PAG_WRITE ) ;
DosFreeMem ( Memory2 ) ;
if ( Status ) {
Log ( "ERROR: Unable to give shared memory. Status %d.", Status ) ;
return ( 1 ) ;
} /* endif */
// Pass the information to the original process.
Sys_PostMessage ( MainWindow, WM_LOAD_FILE, MPFROMP(Memory1), MPFROMP(Memory2) ) ;
} /* endif */
// Bring the previous instance to the fore.
Sys_SetActiveWindow ( MainWindow ) ;
// We're outta here . . .
return ( 0 ) ;
} /* endif */
/**************************************************************************
* If the ISPELL environment variable isn't set, set it to the current *
* directory, before we change it. This assumes that the current *
* directory is also the directory to which Escriba (and ISPELL) was *
* installed. This is true with the basic installation. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Setting ISPELL environment variable." ) ;
#endif // DEBUG
{
char *p = getenv ( "ISPELL" ) ;
if ( p == 0 ) {
static char SetString [_MAX_PATH+10] ;
sprintf ( SetString, "ISPELL=%s", HomePath ) ;
_putenv ( SetString ) ;
} /* endif */
}
/**************************************************************************
* Get application language module. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Loading default language." ) ;
#endif // DEBUG
char DefaultLanguage [80] = { 0 } ;
{ /* startblock */
Profile IniFile ( PSZ(PROGRAM_NAME), 0, HomePath ) ;
if ( IniFile.QueryHandle() )
IniFile.GetString ( "Language", DefaultLanguage, sizeof(DefaultLanguage) ) ;
else
strcpy ( DefaultLanguage, "English" ) ;
} /* endblock */
Library = Language_Create ( PROGRAM_NAME, REVISION, IDS_TITLE1, DefaultLanguage ) ;
if ( Library == 0 ) {
Process Proc ( PROGRAM_NAME, HWND_DESKTOP, 0 ) ;
Debug ( HWND_DESKTOP, "ERROR: Unable to find language module for %s, %s, %s.", PROGRAM_NAME, REVISION, DefaultLanguage ) ;
return ( 1 ) ;
} /* endif */
LibraryHandle = Library->QueryHandle() ;
/**************************************************************************
* Get the program title. *
**************************************************************************/
ResourceString Title ( Library->QueryHandle(), IDS_TITLE ) ;
/**************************************************************************
* Determine the default codepage. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Determining codepage to use." ) ;
#endif // DEBUG
PUSHORT pCodePage = Library->QueryCodepages() ;
while ( *pCodePage ) {
if ( !DosSetProcessCp ( *pCodePage ) )
break ;
pCodePage ++ ;
} /* endwhile */
if ( *pCodePage == 0 ) {
ResourceString Format ( Library->QueryHandle(), IDS_WARNING_BADCODEPAGE ) ;
CHAR Message [200] ;
sprintf ( Message, PCHAR(Format), *Library->QueryCodepages() ) ;
Log ( "%s", Message ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message),
PSZ(Title), 0, MB_ENTER | MB_ICONEXCLAMATION, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
return ( 1 ) ;
} /* endif */
/**************************************************************************
* Initialize the process with an extra-large message queue. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Connecting to PM." ) ;
#endif // DEBUG
Process Proc ( PCHAR(Title), HWND_DESKTOP, Library->QueryHandle(), 100, *pCodePage ) ;
if ( Proc.QueryAnchor() == 0 )
return ( 1 ) ;
/**************************************************************************
* Register the custom control classes. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Registering custom control classes." ) ;
#endif // DEBUG
RegisterControls ( Proc.QueryAnchor() ) ;
/**************************************************************************
* Open up debug timer. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Opening debug timer." ) ;
#endif // DEBUG
OpenTimer ( ) ;
/**************************************************************************
* Open the registration library, if it is present. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to open registration file." ) ;
#endif // DEBUG
char *RegistrationName = PROGRAM_NAME"R" ;
Module *pRegistration = new Module ( RegistrationName, FALSE ) ;
if ( pRegistration->QueryHandle() == 0 )
RegistrationName = "PLUMAR" ;
delete pRegistration, pRegistration = 0 ;
Module Registration = Module ( RegistrationName, FALSE ) ;
/**************************************************************************
* Load any extenders (except spell-check). *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to load extenders." ) ;
#endif // DEBUG
AddonList.Build ( DefaultLanguage ) ;
/**************************************************************************
* Get the country information. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to get country information." ) ;
#endif // DEBUG
GetCountryInfo ( 0, 0 ) ;
/**************************************************************************
* Set any language-specific globals. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to set language-specific globals." ) ;
#endif // DEBUG
ResourceString AllGraphicFiles ( LibraryHandle, IDS_ALL_GRAPHICS ) ;
GraphicTypeList[0] = PSZ ( AllGraphicFiles ) ;
/**************************************************************************
* Check for command-line options and remove them from the argument list. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to parse the command line." ) ;
#endif // DEBUG
ResourceString ResetCommand ( Library->QueryHandle(), IDS_PARMS_RESET ) ;
BOOL Reset = FALSE ;
// ResourceString PrintCommand ( Library->QueryHandle(), IDS_PARMS_PRINT ) ;
// BOOL Print = FALSE ;
ResourceString TrapCommand ( Library->QueryHandle(), IDS_PARMS_TRAP ) ;
BOOL Trap = FALSE ;
int i = 1 ;
char **p = argv + 1 ;
while ( i < argc ) {
if ( **p == '-' ) {
if ( !stricmp ( (*p)+1, PCHAR(ResetCommand) ) ) {
Reset = TRUE ;
// } else if ( !stricmp ( (*p)+1, PCHAR(PrintCommand) ) ) {
// Print = TRUE ;
} else if ( !stricmp ( (*p)+1, PCHAR(TrapCommand) ) ) {
Trap = TRUE ;
} else {
Debug ( HWND_DESKTOP, "ERROR: Invalid command-line parameter '%s'.", (*p)+1 ) ;
return ( 1 ) ;
} /* endif */
for ( int j=i+1; j<argc; j++ ) {
argv[j-1] = argv[j] ;
} /* endfor */
argv[j] = 0 ;
argc -- ;
continue ;
} /* endif */
i ++ ;
p ++ ;
} /* endwhile */
/**************************************************************************
* Create the help instance. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to create the help instance." ) ;
#endif // DEBUG
_splitpath ( Library->QueryName(), Drive, Dir, Fname, Ext ) ;
char HelpFileName [CCHMAXPATH] ;
sprintf ( HelpFileName, "%s.hlp", Fname ) ;
ResourceString HelpTitle ( Library->QueryHandle(), IDS_HELPTITLE ) ;
Help = new HelpWindow ( Proc.QueryAnchor(), 0, ID_MAIN, PSZ(HelpFileName), PSZ(HelpTitle) ) ;
if ( Help->QueryHandle() == 0 ) {
ERRORID Error = Sys_GetLastError ( Proc.QueryAnchor() ) ;
ResourceString Format ( Library->QueryHandle(), IDS_ERROR_CREATEHELP ) ;
CHAR Message [200] ;
sprintf ( Message, PCHAR(Format), Error ) ;
Log ( "%s", Message ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message), PSZ(Title), 0, MB_ENTER | MB_ICONEXCLAMATION, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
} /* endif */
/**************************************************************************
* Open/create the profile file. Reset if requested. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to open profile file." ) ;
#endif // DEBUG
Profile2 IniFile ( PSZ(PROGRAM_NAME), Proc.QueryAnchor(), Library->QueryHandle(),
IDD_PROFILE_PATH, Help, Reset ) ;
if ( IniFile.QueryHandle() == 0 ) {
ResourceString Message ( Library->QueryHandle(), IDS_ERROR_PRFOPENPROFILE ) ;
Log ( "%s", PSZ(Message) ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message), PSZ(Title), 0, MB_ENTER | MB_ICONEXCLAMATION, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
CloseTimer() ;
return ( 2 ) ;
} /* endif */
/**************************************************************************
* Get profile data. Try the OS2.INI first, then try for private INI. *
* If obtained from OS2.INI, erase it afterwards and resave it. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to get profile data." ) ;
#endif // DEBUG
INIDATA IniData ( Registration.QueryHandle() ) ;
IniFile.GetIniData ( IniData ) ;
if ( IniData.Language [0] == 0 )
strcpy ( IniData.Language, DefaultLanguage ) ;
/**************************************************************************
* Activate the spell checker, if it is present. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to open the default dictionary." ) ;
#endif // DEBUG
char SpellerPath [ CCHMAXPATH ] = { 0 } ;
if ( getenv ( "ISPELL" ) ) {
strcpy ( SpellerPath, getenv ( "ISPELL" ) ) ;
strcat ( SpellerPath, "\\" ) ;
} /* endif */
strcat ( SpellerPath, "ISPELLER.DLL" ) ;
Dictionary *Speller = new Dictionary ( SpellerPath, DefaultLanguage ) ;
if ( Speller->QueryLibrary() == 0 ) {
#ifdef DEBUG
Log ( "Escriba::main: Could not find spellchecker. Will try again through LIBPATH." ) ;
#endif // DEBUG
delete Speller, Speller = 0 ;
Speller = new Dictionary ( "ISPELLER", DefaultLanguage ) ;
} /* endif */
if ( Speller->Available() ) {
#ifdef DEBUG
Log ( "Escriba::main: Adding dictionary object to extension list." ) ;
#endif // DEBUG
AddonList.Add ( Speller ) ;
} else {
#ifdef DEBUG
Log ( "Escriba::main: Dictionary object could not be fully created." ) ;
#endif // DEBUG
delete Speller, Speller = 0 ;
} /* endif */
/**************************************************************************
* Create the frame window. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to create the frame window." ) ;
#endif // DEBUG
FRAMECDATA FrameControlData ;
FrameControlData.cb = sizeof(FrameControlData) ;
FrameControlData.flCreateFlags =
FCF_TITLEBAR | FCF_MENU | FCF_ICON | FCF_NOBYTEALIGN | FCF_ACCELTABLE | FCF_SYSMENU |
( Trap ? 0 : FCF_SIZEBORDER | FCF_MINMAX ) ;
FrameControlData.hmodResources = USHORT ( Library->QueryHandle() ) ;
FrameControlData.idResources = ID_MAIN ;
Window Frame ( HWND_DESKTOP, WC_FRAME, PSZ(Title),
IniData.Animate ? WS_ANIMATE : 0,
0, 0, 0, 0, HWND_DESKTOP, HWND_TOP, ID_MAIN,
&FrameControlData, NULL ) ;
if ( Frame.QueryHandle() == 0 ) {
ERRORID Error = Sys_GetLastError ( Proc.QueryAnchor() ) ;
ResourceString Format ( Library->QueryHandle(), IDS_ERROR_CREATEFRAME ) ;
CHAR Message [200] ;
sprintf ( Message, PCHAR(Format), Error ) ;
Log ( "%s", Message ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message), PSZ(Title), 0, MB_ENTER | MB_ICONEXCLAMATION, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
CloseTimer() ;
return ( 3 ) ;
} /* endif */
/**************************************************************************
* Associate the help instance with the frame window. *
**************************************************************************/
Help->Associate ( Frame.QueryHandle() ) ;
/**************************************************************************
* Register the client window class. *
**************************************************************************/
if ( !WinRegisterClass ( Proc.QueryAnchor(), PSZ(CLASS_NAME),
MessageProcessor, CS_MOVENOTIFY, sizeof(PVOID) ) ) {
ERRORID Error = Sys_GetLastError ( Proc.QueryAnchor() ) ;
ResourceString Format ( Library->QueryHandle(), IDS_ERROR_WINREGISTERCLASS ) ;
CHAR Message [200] ;
sprintf ( Message, PCHAR(Format), CLASS_NAME, Error ) ;
Log ( "%s", Message ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message),
PSZ(Title), IDD_ERROR_WINREGISTERCLASS, MB_ENTER | MB_ICONEXCLAMATION | MB_HELP, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
CloseTimer() ;
return ( 4 ) ;
} /* endif */
/**************************************************************************
* Build the presentation parameters for the main window. *
**************************************************************************/
COLOR BackColor = IniData.fMainColors[0] ? IniData.MainColors[0] :
WinQuerySysColor ( HWND_DESKTOP, SYSCLR_APPWORKSPACE, 0 ) ;
ULONG Ids[] = { PP_BACKGROUNDCOLOR } ;
ULONG ByteCounts[] = { sizeof(BackColor) } ;
PUCHAR Params[] = { PUCHAR(&BackColor) } ;
PPRESPARAMS PresParams = BuildPresParams ( sizeof(Ids)/sizeof(Ids[0]),
Ids, ByteCounts, Params ) ;
/**************************************************************************
* Create client window. If this fails, destroy frame and return. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to create the client window." ) ;
#endif // DEBUG
PARMS Parms ;
Parms.Filler = 0 ;
Parms.Library = Library ;
Parms.Registration = & Registration ;
Parms.IniFile = & IniFile ;
Parms.IniData = & IniData ;
Parms.Speller = Speller ;
Parms.InitialPath = InitialPath ;
Parms.argc = argc ;
Parms.argv = argv ;
Parms.Trap = Trap ;
Window Client ( Frame.QueryHandle(), PSZ(CLASS_NAME), PSZ(""), WS_CLIPCHILDREN | WS_CLIPSIBLINGS,
0, 0, 0, 0, Frame.QueryHandle(), HWND_BOTTOM, FID_CLIENT, &Parms, PresParams ) ;
free ( PresParams ) ;
if ( Client.QueryHandle() == 0 ) {
ERRORID Error = Sys_GetLastError ( Proc.QueryAnchor() ) ;
ResourceString Format ( Library->QueryHandle(), IDS_ERROR_CREATECLIENT ) ;
CHAR Message [200] ;
sprintf ( Message, PCHAR(Format), Error ) ;
Log ( "%s", Message ) ;
MessageBox ( HWND_DESKTOP, HWND_DESKTOP, PSZ(Message),
PSZ(Title), IDD_ERROR_CREATECLIENT, MB_ENTER | MB_ICONEXCLAMATION | MB_HELP, LibraryHandle, IDS_MESSAGE_BOX_STRINGS ) ;
CloseTimer ( ) ;
return ( 5 ) ;
} /* endif */
((SHARED_MEMORY*)Memory.QueryMemory())->MainWindow = Client.QueryHandle() ;
/**************************************************************************
* Wait for and process messages to the window's queue. Terminate *
* when the WM_QUIT message is received. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to enter the main message loop." ) ;
#endif // DEBUG
Sys_ProcessMessages ( Proc.QueryAnchor() ) ;
/**************************************************************************
* Discard all that had been requested of the system. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: About to close the HR Timer." ) ;
#endif // DEBUG
CloseTimer ( ) ;
/**************************************************************************
* Invoke nearly all the destructors. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Invoking most destructors." ) ;
#endif // DEBUG
} /* Invoke all destructors except the global ones. */
/**************************************************************************
* Invoke the remaining destructors. *
**************************************************************************/
#ifdef DEBUG
Log ( "Escriba::main: Clearing the addon list." ) ;
#endif // DEBUG
AddonList.Clear ( ) ;
#ifdef DEBUG
Log ( "Escriba::main: Clearing the file type list." ) ;
#endif // DEBUG
ClearFileTypeList ( ) ;
#ifdef DEBUG
Log ( "Escriba::main: Clearing the graphic type list." ) ;
#endif // DEBUG
ClearGraphicTypeList ( ) ;
#ifdef DEBUG
Log ( "Escriba::main: Destroying the help instance." ) ;
#endif // DEBUG
if ( Help ) delete Help ;
#ifdef DEBUG
Log ( "Escriba::main: Destroying the language library instance." ) ;
#endif // DEBUG
if ( Library ) delete Library ;
/**************************************************************************
* Check to see if any memory remains allocated. *
**************************************************************************/
#ifdef __DEBUG_ALLOC__
Log ( "Escriba::main: Checking the heap." ) ;
_dump_allocated ( 64 ) ;
Log ( "Escriba::main: Program ended." ) ;
fclose ( Logfile ) ;
#else
#ifdef DEBUG
Log ( "Escriba::main: Program ended." ) ;
#endif // DEBUG
#endif // __DEBUG_ALLOC__
/**************************************************************************
* Discard the exception filter. *
**************************************************************************/
UNREGISTER_EXCEPTION_HANDLER(0);
/**************************************************************************
* Terminate the process. *
**************************************************************************/
return ( 0 ) ;
}
void RegisterInputAPI(asIScriptEngine* engine)
{
RegisterControls(engine);
RegisterInputConstants(engine);
RegisterInput(engine);
}
int main(int argc, char *argv[]){
glutInit(&argc, argv);
GameDebugger* debugger = GameDebugger::GetInstance();
assert(debugger->OpenDebugFile());
debugger->WriteDebugMessageToConsole("Hello, World", 31);
debugger->WriteToDebugFile("Wrote to file", 32);
TaskQueue *taskManager = new TaskQueue(NUM_THREADS);
ConsoleCreateRoom();
GameRoom gr;
if (argc > 1){
string path = pathCat(GAME_DATA_ROOMS_FOLDER, argv[1]);
GameRoom::LoadRoom(path.c_str(), gr);
}
//For testing purposes. To make sure it reads debug.room
char debugName[1000];
strcpy(debugName, GAME_DATA_ROOMS_FOLDER);
strcat(debugName, "debug.room");
GameRoom debug;
assert(GameRoom::LoadRoom(debugName, debug));
vector<GameObject*> obs = debug.GetGameObjects();
//map<string, GameWorldObject>::iterator wobs = debug.GetRoomWorldObjectsIterator();
for(unsigned int w = 0; w<obs.size(); w++){
//load starting meshes
GameObject *gwo = obs[w];
cout<<gwo->GetName()<<endl;
MyMesh *tmp = new MyMesh();
if (gwo->GetMeshFile()){
string fname = pathCat(".", gwo->GetMeshFile());
if (! MyMeshIO::LoadMesh(*tmp, fname)){
cerr<<"couldn't load (" << gwo->GetMeshFile() << ") for " <<gwo -> GetName() <<endl;
gwo->SetMesh(NULL);
}else{
gwo->SetMesh(tmp);
NavShot::room = tmp;
}
}
}
ComputeBoundingBoxesAndPhysicsConstants(obs);
//cin.ignore(1);
///////////////////////////////////////////////////
//TODO: load from file
GameState *gs = GameState::GetInstance();
Vector3f pos(0.0f, 0, -10.0f);
Vector3f up(0, 1.0f, 0);
Vector3f dir(0.0f, 0, 1.0f);
float radius =0, n = 0.1, f = 600, fovy = 80, aspect = ((float)16.0/9.0);
Camera cam(pos, dir, up, radius, n, f, fovy, aspect);
gs->SetRoom(&debug);
gs->SetCamera(&cam);
Vector3f enemyPos(0.0f, 3.0f, 10.0f);
gs->AddActor(new MetaballEnemy(enemyPos, 2, 2.0f));
Render::gameState = gs;
Render::GlutInitialize();
SCollision::gameState = gs;
RegisterControls();
Controller::Initialize(taskManager, gs);
/////////////////////////////////////////////////
// TO DO:
// Pass GameRoom debug to Render module. Render the
// room.
/////////////////////////////////////////////////
glutTimerFunc(0, Controller::GlutSync, 0);
//glutMotionFunc(mouseMoveCB);
//glutMouseFunc(mouseFunc);
Sound::InitializeSounds();
Music *music = new Music("sounds/run2.ogg", 0.3f);
music->Loop();
Sound *backgroundNoise = new Sound("sounds/metallic_roar.wav", 0.2f);
backgroundNoise->Loop();
glutMainLoop(); //this should only be called once, and AT THE END of the initialization routine.
Sound::UninitializeSounds();
assert(debugger->CloseDebugFile());
return 0;
}
