/* Function: PointOut
Creates a pointer for every player pointing to the calling object.
Parameters:
color - Pointer's color modulation.
message - A message shown above the pointer. */
global func PointOut(int color, string message) {
for(var count = GetPlayerCount(), i = 0; i < count; i++) {
var p = GetPlayerByIndex(i);
CreatePointer(p, this, color, message);
}
return count;
}
LRESULT CEsmRefCellPage::OnRecordDrop (LPARAM lParam, LPARAM wParam) {
DEFINE_FUNCTION("CEsmRefCellPage::OnRecordDrop()");
CEsmCell* pCell = (CEsmCell *) m_pRecInfo->pRecord;
CString Buffer;
CMWEditDoc* pSourceDoc = (CMWEditDoc *) lParam;
esmrecinfo_t* pRecInfo = (esmrecinfo_t *) wParam;
CEsmSubCellRef* pNewCellRef;
cellrefdata_t* pCellRefData;
/* Ensure we only drag from the current document */
if (pSourceDoc != GetDocument()) return (0);
/* Only accept certain types */
if (!IsESMRecordModel(pRecInfo->pRecord->GetType())) return (0);
//return (0);
/* Add a new item to the cell */
CreatePointer(pNewCellRef, CEsmSubCellRef);
pNewCellRef->CreateNew((CEsmCell *) m_pRecInfo->pRecord);
pNewCellRef->SetIsActive(true);
pNewCellRef->SetIndex(pCell->GetNextRefIndex(), 0);
pNewCellRef->SetRefName(pRecInfo->pRecord->GetID());
pCellRefData = AddNewCellRef(pNewCellRef);
/* Update the reference list */
m_CellRefList.AddItem(pNewCellRef);
return (0);
}
CEsmFile* CMWEditApp::LoadMaster (const TCHAR* pString, CEsmLoadDlg* pLoadDlg) {
DEFINE_FUNCTION("CMWEditApp::LoadMaster()");
CEsmFile* pFile;
bool Result;
/* Find an existing file */
pFile = FindMaster(pString);
if (pFile != NULL) {
pLoadDlg->SetFilename(pString);
pLoadDlg->SetProgress(100.0f);
return (pFile);
}
/* Create a new file */
CreatePointer(pFile, CEsmFile);
m_EsmMasters.Add(pFile);
pFile->SetMaster(true);
/* Progress dialog initialization */
pLoadDlg->SetFilename(pString);
pLoadDlg->SetSubLabel(_T("Loading..."));
pLoadDlg->SetProgress(0.0f);
pFile->SetCallback(g_EsmLoadDlgCallback, (long) pLoadDlg);
/* Attempt to read the file */
Result = pFile->Read(pString);
if (!Result) {
ErrorHandler.Notify("Master Read Error!");
}
return (pFile);
}
void CEsmRefCellPage::OnCellrefCreatecopy() {
DEFINE_FUNCTION("CEsmRefCellPage::OnCellrefDelete()");
CEsmCell* pCell = (CEsmCell *) m_pRecInfo->pRecord;
POSITION SelPos;
CEsmSubCellRef* pOldCellRef;
CEsmSubCellRef* pNewCellRef;
cellrefdata_t* pCellRefData;
int SelectedIndex;
/* Copy all selected records */
SelPos = m_CellRefList.GetFirstSelectedItemPosition();
while (SelPos != NULL) {
SelectedIndex = m_CellRefList.GetNextSelectedItem(SelPos);
pOldCellRef = (CEsmSubCellRef *) m_CellRefList.GetItemData(SelectedIndex);
if (pOldCellRef == NULL) continue;
CreatePointer(pNewCellRef, CEsmSubCellRef);
pNewCellRef->Copy(pOldCellRef);
pNewCellRef->SetIsActive(true);
pNewCellRef->SetIndex(pCell->GetNextRefIndex(), 0);
pCellRefData = AddNewCellRef(pNewCellRef);
/* Update the reference list */
m_CellRefList.AddItem(pNewCellRef);
}
/* Update the display */
UpdateCellRefList();
}
cellrefdata_t* CEsmRefCellPage::CleanCellRef (CEsmSubCellRef* pCellRef) {
DEFINE_FUNCTION("CEsmRefCellPage::CleanCellRef()");
cellrefdata_t* pCellRefData;
/* See if the record already exists in array */
pCellRefData = FindNewCellRef(pCellRef);
if (pCellRefData != NULL) {
/* Delete a new reference sub-record outright */
if (pCellRefData->IsNew) {
m_ModCellRefs.DeleteElement(pCellRefData);
DestroyPointer(pCellRefData->pNewCellRef);
DestroyPointer(pCellRefData);
return (pCellRefData);
}
/* Update the reference element to clean it */
pCellRefData->Type = ESMCELLREF_MODTYPE_CLEAN;
return (pCellRefData);
}
/* Add a new record to the modified array */
CreatePointer(pCellRefData, cellrefdata_t);
m_ModCellRefs.AddElement(pCellRefData);
/* Initialize the new cell ref data */
pCellRefData->IsNew = false;
pCellRefData->Type = ESMCELLREF_MODTYPE_CLEAN;
pCellRefData->pNewCellRef = pCellRef;
pCellRefData->pOldCellRef = pCellRef;
return (pCellRefData);
}
LRESULT CEsmRefCellPage::OnRecordEdit (LPARAM lParam, LPARAM wParam) {
DEFINE_FUNCTION("CEsmRefCellPage::OnRecordEdit()");
CEsmSubCellRef* pOldCellRef;
CEsmSubCellRef* pNewCellRef;
CEsmCellRefDlg RefDialog;
cellrefdata_t* pCellRefData;
bool Result;
bool IsNew;
bool NewAllocated;
/* Ignore if no record currently selected */
if (lParam < 0) return (0);
pOldCellRef = (CEsmSubCellRef *) m_CellRefList.GetItemData(lParam);
if (pOldCellRef == NULL) return (0);
/* See if the reference record is already 'new' */
pCellRefData = FindNewCellRef(pOldCellRef);
if (pCellRefData == NULL) {
if (pOldCellRef->IsDeleted()) return (0);
IsNew = false;
NewAllocated = true;
CreatePointer(pNewCellRef, CEsmSubCellRef);
pNewCellRef->Copy(pOldCellRef);
}
else {
if (pOldCellRef->IsDeleted()) return (0);
if (pCellRefData->Type == ESMCELLREF_MODTYPE_DEL) return (0);
NewAllocated = false;
IsNew = pCellRefData->IsNew;
pNewCellRef = pCellRefData->pNewCellRef;
}
/* Display the modal edit dialogue */
Result = RefDialog.DoModal(pNewCellRef, true, (CEsmCell *) m_pRecInfo->pRecord);
if (!Result) {
if (NewAllocated) {
DestroyPointer(pNewCellRef);
}
return (0);
}
/* Create a new cell ref data record if required */
if (pCellRefData == NULL) {
pCellRefData = ModifyCellRef(pNewCellRef);
pCellRefData->pOldCellRef = pOldCellRef;
pNewCellRef->SetFRMRFlag(1);
}
else {
pCellRefData->Type = ESMCELLREF_MODTYPE_MOD;
}
/* Update the display */
UpdateCellRefList();
return (0);
}
*=========================================================================*/
CNifCopyInfo* CNifCopyDlg::AddCopyInfo (void) {
DEFINE_FUNCTION("CNifCopyDlg::AddCopyInfo()");
CNifCopyInfo* pNewInfo;
/* Allocate the new pointer */
CreatePointer(pNewInfo, CNifCopyInfo);
m_CopyInfos.Add(pNewInfo);
/* Initialize the new info */
pNewInfo->CsvColIndex = -1;
pNewInfo->pSourceTexture = NULL;
pNewInfo->pMaterialProperty = NULL;
return (pNewInfo);
}
void CEditUndoStack::CreateEntireText (const TCHAR* pString) {
DEFINE_FUNCTION("CEditUndoStack::CreateDeleteString()");
CEditUndo* pUndo;
CreatePointer(pUndo, CEditUndo);
m_UndoStack.Add(pUndo);
pUndo->SetString(pString);
pUndo->SetAction(EDITUNDO_ENTIRETEXT);
pUndo->SetSelStart(0);
pUndo->SetSelEnd(0);
if (m_UndoStack.GetNumElements() > m_Limit) {
m_UndoStack.DeleteElement(0);
}
}
void CEditUndoStack::CreateDeleteString (const TCHAR* pString, const int StartSel, const int EndSel) {
DEFINE_FUNCTION("CEditUndoStack::CreateDeleteString()");
CEditUndo* pUndo;
CreatePointer(pUndo, CEditUndo);
m_UndoStack.Add(pUndo);
pUndo->SetString(pString);
pUndo->SetAction(EDITUNDO_DELETESTRING);
pUndo->SetSelStart(StartSel);
pUndo->SetSelEnd(EndSel);
if (m_UndoStack.GetNumElements() > m_Limit) {
m_UndoStack.DeleteElement(0);
}
}
void CEditUndoStack::CreateInsertChar (const TCHAR Char, const int StartSel, const int EndSel) {
DEFINE_FUNCTION("CEditUndoStack::CreateInsertChar()");
CEditUndo* pUndo;
CreatePointer(pUndo, CEditUndo);
m_UndoStack.Add(pUndo);
pUndo->SetChar(Char);
pUndo->SetAction(EDITUNDO_INSERTCHAR);
pUndo->SetSelStart(StartSel);
pUndo->SetSelEnd(EndSel);
if (m_UndoStack.GetNumElements() > m_Limit) {
m_UndoStack.DeleteElement(0);
}
}
cellrefdata_t* CEsmRefCellPage::AddNewCellRef (CEsmSubCellRef* pCellRef) {
DEFINE_FUNCTION("CEsmRefCellPage::CleanCellRef()");
cellrefdata_t* pCellRefData;
/* Add a new record to the modified array */
CreatePointer(pCellRefData, cellrefdata_t);
m_ModCellRefs.AddElement(pCellRefData);
/* Initialize the new cell ref data */
pCellRefData->IsNew = true;
pCellRefData->Type = ESMCELLREF_MODTYPE_NEW;
pCellRefData->pOldCellRef = NULL;
pCellRefData->pNewCellRef = pCellRef;
return (pCellRefData);
}
cellrefdata_t* CEsmRefCellPage::ModifyCellRef (CEsmSubCellRef* pCellRef) {
DEFINE_FUNCTION("CEsmRefCellPage::DeleteCellRef()");
cellrefdata_t* pCellRefData;
/* See if the record already exists in array */
pCellRefData = FindNewCellRef(pCellRef);
if (pCellRefData != NULL) {
pCellRefData->Type = ESMCELLREF_MODTYPE_MOD;
return (pCellRefData);
}
/* Add a new record to the modified array */
CreatePointer(pCellRefData, cellrefdata_t);
m_ModCellRefs.AddElement(pCellRefData);
/* Initialize the new cell ref data */
pCellRefData->IsNew = false;
pCellRefData->Type = ESMCELLREF_MODTYPE_MOD;
pCellRefData->pNewCellRef = pCellRef;
pCellRefData->pOldCellRef = pCellRef;
return (pCellRefData);
}
}
/*===========================================================================
* End of Class Method CEsmRefCellPage::DeleteCellRef()
*=========================================================================*/
/*===========================================================================
*
* Class CEsmRefCellPage Method - void DeleteIndex (ListIndex, Delete);
*
* Deletes or undeletes the given list record.
*
*=========================================================================*/
void CEsmRefCellPage::DeleteIndex (const int ListIndex, const bool Delete) {
DEFINE_FUNCTION("CEsmRefCellPage::DeleteIndex()");
CEsmSubCellRef* pOldCellRef;
CEsmSubCellRef* pNewCellRef;
CEsmCellRefDlg RefDialog;
cellrefdata_t* pCellRefData;
/* Get the given cell reference object */
pOldCellRef = (CEsmSubCellRef *) m_CellRefList.GetItemData(ListIndex);
if (pOldCellRef == NULL) return;
/* See if the reference record is already 'new' */
pCellRefData = FindNewCellRef(pOldCellRef);
if (pCellRefData == NULL) {
CreatePointer(pNewCellRef, CEsmSubCellRef);
pNewCellRef->Copy(pOldCellRef);
}
else {
pNewCellRef = pCellRefData->pNewCellRef;
}
/* Create a new cell ref data record if required */
if (pCellRefData == NULL) {
pCellRefData = DeleteCellRef(pNewCellRef);
pCellRefData->pOldCellRef = pOldCellRef;
pCellRefData->pNewCellRef = pNewCellRef;
}
else {
pCellRefData->Type = ESMCELLREF_MODTYPE_DEL;
}
/* Delete or undelete the reference */
pCellRefData->pNewCellRef->SetDelete(Delete);
pCellRefData->pNewCellRef->SetFRMRFlag(1);
}
int SDLShell::Run(int argc, char *argv[])
{
printf("*** %s, V%s ***\n", GetAppName(), GetAppVersion());
int done;
Uint8 *keys;
if (SDL_Init(SDL_INIT_VIDEO))
{
printf("Unable to initialize SDL: %s\n", SDL_GetError());
return 0;
}
ProcessCommandLine(argc, argv);
if (!InitApp())
{
Exit(EXIT_INIT_APP);
}
SDL_Surface *screen;
if (Verbose(VerboseAll))
{
printf("Setting width = %d, height = %d, bpp = %d\n",
ShellGet(SDLShell::SHELL_WIDTH),
ShellGet(SDLShell::SHELL_HEIGHT),
ShellGet(SDLShell::SHELL_BPP));
}
screen = SDL_SetVideoMode(ShellGet(SDLShell::SHELL_WIDTH),
ShellGet(SDLShell::SHELL_HEIGHT),
ShellGet(SDLShell::SHELL_BPP), Flags());
if (!screen)
{
fprintf(stderr, "Couldn't set %dx%d GL video mode: %s\n",
ShellGet(SDLShell::SHELL_WIDTH),
ShellGet(SDLShell::SHELL_HEIGHT), SDL_GetError());
Exit(EXIT_NO_SCREEN);
}
char tempString[100];
sprintf(tempString, "%s V%s", GetAppName(), GetAppVersion());
SDL_WM_SetCaption(tempString, GetAppName());
SDL_GL_SetAttribute(SDL_GL_SWAP_CONTROL, ShellGet(SHELL_VSYNC));
if (RequiresOpenGL2())
{
// Initialize GLEW and make sure OpenGL 2.0 is supported
GLenum err = glewInit();
if(GLEW_OK != err)
{
fprintf(stderr, "[ Fail ] - Error: %s\n", glewGetErrorString(err));
Exit(EXIT_NO_GL2_SUPPORT);
}
if(!GLEW_VERSION_2_0 &&
!(GLEW_ARB_shading_language_100 && GLEW_ARB_shader_objects &&
GLEW_ARB_vertex_shader && GLEW_ARB_fragment_shader))
{
fprintf(stderr, "[ Fail ] - Shaders not supported\n");
Exit(EXIT_NO_GL2_SUPPORT);
}
if(!GLEW_ARB_vertex_buffer_object)
{
fprintf(stderr, "[ Fail ] - VBO objects are not supported\n");
Exit(EXIT_NO_GL2_SUPPORT);
}
}
if (RequiresTTF())
{
if (TTF_Init() == -1)
{
printf("Unable to initialize SDL_ttf: %s \n", TTF_GetError());
Exit(EXIT_NO_FONT);
}
}
CreatePointer();
if (!InitGL())
{
Exit(EXIT_INIT_GL);
}
done = 0;
while (!done)
{
pPointer->Input();
ResetPressed();
ResetMouse();
SDL_Event event;
while ( SDL_PollEvent(&event) )
{
switch(event.type)
{
case SDL_VIDEORESIZE:
if (ShellGet(SDLShell::SHELL_RESIZABLE))
{
screen = SDL_SetVideoMode(event.resize.w, event.resize.h,
ShellGet(SDLShell::SHELL_BPP),
Flags());
if (screen)
{
Reshape(screen->w, screen->h);
}
else
{
/* Uh oh, we couldn't set the new video mode?? */;
}
}
break;
case SDL_MOUSEMOTION:
pPointer->UpdateMouseMotion(event.motion);
/*if (Verbose(VerboseAll))
{
printf("Mouse moved by %d,%d to (%d,%d)\n",
event.motion.xrel, event.motion.yrel,
event.motion.x, event.motion.y);
}*/
break;
case SDL_MOUSEBUTTONDOWN:
if (event.button.button == SDL_BUTTON_WHEELDOWN)
{
scrollDown = true;
}
pPointer->UpdateMouseButton(event.button);
/*if (Verbose(VerboseAll))
{
printf("Mouse button %d pressed at (%d,%d)\n",
event.button.button, event.button.x, event.button.y);
}*/
break;
case SDL_MOUSEBUTTONUP:
if (event.button.button == SDL_BUTTON_WHEELUP)
{
scrollUp = true;
}
if (event.button.button == SDL_BUTTON_LEFT)
{
leftClick = true;
}
if (event.button.button == SDL_BUTTON_RIGHT)
{
rightClick = true;
}
pPointer->UpdateMouseButton(event.button);
/*if (Verbose(VerboseAll))
{
printf("Mouse button %d released at (%d,%d)\n",
event.button.button, event.button.x, event.button.y);
}*/
break;
case SDL_KEYUP:
SetPressed(event.key.keysym.scancode, false);
SetPressing(event.key.keysym.scancode, false);
break;
case SDL_KEYDOWN:
if (Verbose(VerboseInfo))
{
printf("Pressed key %d\n", (int)event.key.keysym.scancode);
}
if (!KeyPressing(event.key.keysym.scancode))
{
SetPressed(event.key.keysym.scancode, true);
}
SetPressing(event.key.keysym.scancode, true);
break;
case SDL_QUIT:
done = 1;
break;
}
}
keys = SDL_GetKeyState(NULL);
if (keys[SDLK_ESCAPE])
{
done = 1;
}
if (!Render())
break;
SDL_GL_SwapBuffers();
shellFrame++;
}
ReleaseGL();
ReleaseApp();
SDL_Quit();
return 0; /* ANSI C requires main to return int. */
}
