Descent3/legacy/editor/HogDialog.cpp

/*
* Descent 3 
* Copyright (C) 2024 Parallax Software
*
* 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 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/

// HogDialog.cpp : implementation file
//

#include "stdafx.h"
#include <afxtempl.h>

#include "editor.h"

#include "hogfile.h"
#include "HogDialog.h"
#include "pserror.h"

#include <stdio.h>
#include <malloc.h>
#include <string.h>

#ifdef _DEBUG
#define new DEBUG_NEW
#undef THIS_FILE
static char THIS_FILE[] = __FILE__;
#endif


/////////////////////////////////////////////////////////////////////////////
//	data structures
/*
typedef struct hog_library {
	CList <hog_library_entry, hog_library_entry&> table;
	FILE *fp;
} hog_library;
*/


/////////////////////////////////////////////////////////////////////////////
//	Hogfile manipulation functions
/*
//	creates a new hogfile
//		does nothing else really
hog_library *new_hogfile(char *hogname)
{
	FILE *fp;
	hog_library *hogfile;

	fp = fopen( hogname, "wb" );
	if ( fp == NULL ) return NULL;

	fwrite(LIBRARY_TAG, 4, 1, fp);

	hogfile = new hog_library;
	hogfile->fp = fp;

	return hogfile;
}	


//	this opens an existing hogfile
//		loads in file listing and hog info.
hog_library *open_hogfile(char *hogname)
{
	FILE *fp, *fplst;
	char *strptr;
	char filename[MAX_PATH];
	int id, nfiles;
	int i,offset,t;
	index_entry *index;
	hog_library *hogfile = NULL;

	strcpy(filename, hogname);
	strptr = strstr(filename, ".hog");
	if (strptr) {
		strptr[0] = 0;					// terminate this string
	}
	strcat(filename, ".lst");			// load in list file too.

	fp = fopen( hogname, "rb" );
	if ( fp == NULL ) return NULL;
	fplst = fopen(filename, "rb");
	if ( fplst == NULL ) {
		fclose(fp);
		OutrageMessageBox("Unable to open hogfile's database. <%s>\n", filename);
		return (hog_library *)0xffffffff;
	}

	fread( &id, sizeof(int), 1, fp );
	if ( strncmp( (char *) &id, LIBRARY_TAG, strlen(LIBRARY_TAG) ) ) {
		fclose(fp);
		fclose(fplst);
		OutrageMessageBox("Invalid hog file <%s>\n", hogname);
		return (hog_library *)0xffffffff;
	}

	fread(&nfiles,sizeof(int),1,fp);		// get number of files
	index = new index_entry[nfiles];		// allocate file index.
 	hogfile = new hog_library;	
	hogfile->fp = fp;
	
//	id + nfiles + nfiles * (filename + size)
	offset = sizeof(int)+sizeof(int)+nfiles*(LIB_FILENAME_LEN+sizeof(int));	

//	read in index table
	t = fread( index, sizeof(index_entry), nfiles, fp );
	if ( t != nfiles )	{					//eof here is ok
		fclose(fp);
		fclose(fplst);
		OutrageMessageBox("Hogfile's file index corrupt <%s>.\n", hogname);
		return (hog_library *)0xffffffff;	//CF_BAD_LIB;
	}

//	copy disk index to our internal structure (generate our dynamic list.)
	for (i=0;i<nfiles;i++) 
	{
		hog_library_entry entry;

	// get database path for filename
		fgets(entry.path, LIB_PATHNAME_LEN, fplst);
		if (entry.path[strlen(entry.path)-1] == '\n') 
			entry.path[strlen(entry.path)-1] = 0;	// get rid of newline, if there

	// create library entry from index entry.
		strcpy(entry.name, index[i].name);
		entry.length = index[i].len;
		entry.offset = offset;
	#if LIB_HAS_DATE
		entry.timestamp = index[i].timestamp;
	#else
		entry.timestamp = 0;
	#endif
	#if LIB_HAS_FLAGS
		entry.flags = index[i].flags;
	#else
		entry.flags = 0;
	#endif
		hogfile->table.AddTail(entry);

		offset += entry.length;
	}

	delete[] index;

	fclose(fplst);

	return hogfile;
}


//	deallocates all info in library struct
void close_hogfile(hog_library *hogfile)
{
	fclose(hogfile->fp);
	delete hogfile;
}


//	copies a file to the hogfile!
int copy_file_to_hog(hog_library *hogfile, FILE *srcfp)
{



	return 1;
}


//	save hog file
//		writes out complete hogfile copying info
//		returns 0 if standard error

int write_hogfile(hog_library *library)
{
	index_entry *index = NULL;
	int nfiles, index_pos;	//, pos
	
	nfiles = library->table.GetCount();
	if (nfiles != 0) {
		index = new index_entry[nfiles];
		if (index == NULL) {
			OutrageMessageBox("Unable to allocate memory for hogfile write.");
			return 0;
		}
	}

//	write out num elements
	fseek(library->fp, sizeof(int), SEEK_SET);
	fwrite(&nfiles, sizeof(int), 1, library->fp);

	if (nfiles == 0) return 1;				// if no files, we are done.

//	write out file dummy index
	index_entry dummy;
	index_pos= ftell(library->fp);
	ZeroMemory(&dummy, sizeof(dummy));
	if (fwrite(&dummy, sizeof(index_entry), nfiles, library->fp) != (unsigned)nfiles) {
		OutrageMessageBox("Out of space!!!");
		delete[] index;
		return 0;
	}

//	copy the files to the hogfile!
	
	

	return 1;
}
*/

/////////////////////////////////////////////////////////////////////////////
// CHogDialog dialog


CHogDialog::CHogDialog(CWnd* pParent, char *filename)
	: CDialog(CHogDialog::IDD, pParent)
{
	//{{AFX_DATA_INIT(CHogDialog)
		// NOTE: the ClassWizard will add member initialization here
	//}}AFX_DATA_INIT

	m_HogName = filename;
}


void CHogDialog::DoDataExchange(CDataExchange* pDX)
{
	CDialog::DoDataExchange(pDX);
	//{{AFX_DATA_MAP(CHogDialog)
		// NOTE: the ClassWizard will add DDX and DDV calls here
	//}}AFX_DATA_MAP
}


BEGIN_MESSAGE_MAP(CHogDialog, CDialog)
	//{{AFX_MSG_MAP(CHogDialog)
	ON_WM_SHOWWINDOW()
	//}}AFX_MSG_MAP
END_MESSAGE_MAP()

/////////////////////////////////////////////////////////////////////////////
// CHogDialog message handlers

BOOL CHogDialog::OnInitDialog() 
{
	CDialog::OnInitDialog();
	
// TODO: Add extra initialization here
	m_ListCtrl = (CListCtrl *)GetDlgItem(IDC_HOGLIST);	
	m_ListCtrl->InsertColumn(0, "Filename", LVCFMT_LEFT, 140);
	m_ListCtrl->InsertColumn(1, "Date", LVCFMT_LEFT, 80);
	m_ListCtrl->InsertColumn(2, "Length", LVCFMT_LEFT, 80);
	m_ListCtrl->InsertColumn(3, "Attributes", LVCFMT_LEFT, 120);

// open hogfile or create new one.
/*	m_Library = open_hogfile(m_HogName);
	if (!m_Library) {
		int res = MessageBox("Hogfile does not exist.  Do you wish to create a new one?", "Hogmaker", MB_YESNO);
		if (res == IDNO) {
			EndDialog(IDCANCEL);
			return TRUE;
		}
		else {
			m_Library = new_hogfile(m_HogName);
			if (!m_Library) {
				MessageBox("Unable to create hogfile.", "Error", MB_OK);
				EndDialog(IDCANCEL);
				return TRUE;
			}
		}
	}
	else if (m_Library == (hog_library *)0xffffffff) {
		MessageBox("Hogmaker failure.  Sorry...", "Hogmaker", MB_OK);
		EndDialog(IDCANCEL);
		return TRUE;
	}
*/
	return TRUE;  // return TRUE unless you set the focus to a control
	              // EXCEPTION: OCX Property Pages should return FALSE
}


void CHogDialog::OnShowWindow(BOOL bShow, UINT nStatus) 
{
	CDialog::OnShowWindow(bShow, nStatus);
	
// TODO: Add your message handler code here
}