frmhistory.c

WAP browser is based on the Wireless Application Protocol web browser, WAP1.3 will enable mobile pho

#include "../res/WAPUniverse_res.h"
#include "WAPUniverse.h"
#include "PalmUtils.h"

//Globals
MemHandle  memoH				= NULL;

/***********************************************************************
 *
 *	Returns the title of the memo (first line or 1st 40 chars which ever is shorter)
 *
 *	Paramaters:		memo	: Char*	- the full memo
 *								title	: Char*	- space to store title
 *
 *	Returns:			Nothing
 *
 ***********************************************************************/
extern void GetMemoTitle(Char* memo, Char* title)
{
    char *cp0, *cp1;

    //copy memo title, first line or up to 40 chars, which ever is less
    for (cp0 = memo, cp1 = title; *cp0 && *cp0 != '\n' && *cp0 != '\r' && cp0 - memo < 40; )
    {
			*cp1++ = *cp0++;
		}
		
    *cp1 = '\0';
}



/***********************************************************************
 *
 *	Clears the history records
 *
 *	Paramaters:		None
 *
 *	Returns:			Err	- 0 => no error
 *
 ***********************************************************************/
extern Err ClearHistory(void)
{
  DmOpenRef MemoDB;
	Char			title[40];
//	MemHandle  memoH				= NULL;
	Char*	sMemo				= NULL;
	Err			err					= 0;	
	UInt16	index				= 0;
	UInt32	newRecSize	= 0;
	Boolean	stop				= false;
	Boolean	bGotRecord	= false;
	UInt16	attr				= 0;

	
	//open memo DB
  MemoDB = DmOpenDatabaseByTypeCreator('DATA', 'memo', dmModeReadWrite);
  
  
  if (!MemoDB)
  {
  	//couldn't open

  	//note error
  	err = 1;
  }
  else
  {
		//go through entries in category
		stop = false;
		
		while(!stop)
		{
			//get next record
			memoH = DmQueryNextInCategory (MemoDB, &index, dmUnfiledCategory);
			
			if(!memoH)
			{
				//error
				err = 1;
				
				//stop
				stop = true;
			}
			else
			{
				sMemo = MemHandleLock(memoH);
				
				if(!sMemo)
				{
					//note error
					err = 1;

					//stop
					stop = true;
				}
				else
				{
					//get title
					GetMemoTitle(sMemo, title);
					
					//compare title to url
					if(StrCompare(title, "WAPUniverse History") == 0)
					{
						//got it!
						bGotRecord = true;
						
						//stop
						stop = true;
					}

					//unlock					
					MemHandleUnlock(memoH);
				}
			}
			
			index++;
		}
		
		//we've added one to the index already
		index--;

		//if we've got a record
		if(bGotRecord)
		{
			//get old record
			memoH = DmGetRecord(MemoDB, index);
			
			if(!memoH)
			{
				err = 1;
			}
			else
			{
				//lock it
				sMemo = MemHandleLock(memoH);
			
				if(!sMemo)
				{
					err = 1;
				}
				else
				{
					//get title
					GetMemoTitle(sMemo, title);
				
					//new size
					newRecSize = StrLen(title) + 1 + 1; // +\n + \0
					
					//unlock
					MemHandleUnlock(memoH);
					
					//resize record
					memoH = DmResizeRecord(MemoDB, index, newRecSize); // +\n +\0

					if(!memoH)
					{
						err = 1;
					}						
					else
					{
						//lock
						sMemo = MemHandleLock(memoH);							
						
						if(!sMemo)
						{
							err = 1;
						}
						else
						{
							//write new in
							err = DmStrCopy(sMemo, 0, title);
							err = DmStrCopy(sMemo, StrLen(sMemo), "\n");
							
							//unlock
							MemHandleUnlock(memoH);
						}
					}
				}

				DmReleaseRecord(MemoDB, index, true);
			}
		}
	
		DmCloseDatabase(MemoDB);
	}

	return err;
}


/***********************************************************************
 *
 *	Writes URLs to History
 *
 *	Paramaters:		text	: Char*	- text to be logged
 *
 *	Returns:			Err - 0 => no error
 *
 ***********************************************************************/
extern Err History(Char* text)
{
  DmOpenRef MemoDB;
	Char			title[40];
//	MemHandle  memoH				= NULL;
	Char*	sMemo				= NULL;
	Err			err					= 0;	
	UInt16	index				= 0;
	UInt32	newRecSize	= 0;
	Boolean	stop				= false;
	Boolean	bGotRecord	= false;
	UInt16	attr				= 0;

	
	if(true && "WAPUniverse History" && StrLen("WAPUniverse History") > 0)
	{
	  MemoDB = DmOpenDatabaseByTypeCreator('DATA', 'memo', dmModeReadWrite);
	  
	  
	  if (!MemoDB)
	  {

	  	err = 1;
	  }
	  else
	  {
			stop = false;
			
			while(!stop)
			{
				memoH = DmQueryNextInCategory (MemoDB, &index, dmUnfiledCategory);
				
				if(!memoH)
				{
					err = 1;
					stop = true;
				}
				else
				{
					sMemo = MemHandleLock(memoH);
					
					if(!sMemo)
					{
						err = 1;
						stop = true;
					}
					else
					{
						GetMemoTitle(sMemo, title);
						if(StrCompare(title, "WAPUniverse History") == 0)
						{
							bGotRecord = true;
							stop = true;
						}				
						MemHandleUnlock(memoH);
					}
				}
				
				index++;
			}
			
			index--;


			if(!bGotRecord)
			{
				index = dmMaxRecordIndex;
				memoH = DmNewRecord(MemoDB, &index, StrLen("WAPUniverse History") + 1);
				
				if(!memoH)
				{
					err = 1;
				}
				else
				{
					sMemo = MemHandleLock(memoH);
					
					if(!sMemo)
					{
						err = 1;
						DmReleaseRecord(MemoDB, index, true);
						DmRemoveRecord(MemoDB, index);
					}
					else
					{
						err = DmStrCopy(sMemo, 0, "WAPUniverse History");
						MemHandleUnlock(memoH);
						DmReleaseRecord(MemoDB, index, true);					
						DmRecordInfo(MemoDB, index, &attr, NULL, NULL);
						attr = attr & 0xFFF0;
						attr = attr | dmUnfiledCategory;
						DmSetRecordInfo(MemoDB, index, &attr, NULL);
					}
				}
		
				if(!err)
				{
					bGotRecord = true;
				}
			}
			
			
			if(bGotRecord)
			{
				memoH = DmGetRecord(MemoDB, index);
				
				if(!memoH)
				{
					err = 1;
				}
				else
				{
					sMemo = MemHandleLock(memoH);
				
					if(!sMemo)
					{
						err = 1;
					}
					else
					{
						GetMemoTitle(sMemo, title);
						newRecSize = StrLen(sMemo) + StrLen(text) + 1 + 1; // +\n + \0
						MemHandleUnlock(memoH);
						memoH = DmResizeRecord(MemoDB, index, newRecSize);

						if(!memoH)
						{
							err = 1;
						}						
						else
						{
							sMemo = MemHandleLock(memoH);							
							
							if(!sMemo)
							{
								err = 1;
							}
							else
							{
								err = DmStrCopy(sMemo, StrLen(sMemo), "\n");
								err = DmStrCopy(sMemo, StrLen(sMemo), text);
								MemHandleUnlock(memoH);
							}
						}
					}
	
					DmReleaseRecord(MemoDB, index, true);
				}
			}

			DmCloseDatabase(MemoDB);
		}
	}

	return err;
}


/***********************************************************************
 *
 *	History form event handler
 *
 *	Paramaters:		event : EventPtr		- pointer to the event
 *
 *	Returns:			Boolean							- true if vent was handled, false otherwise
 *
 ***********************************************************************/
Boolean ehFrmHistory(EventPtr event)
{
  Boolean handled = false;
  FormPtr frmP;
  Err			err			= 0;
	DmOpenRef	MemoDB	= NULL;
	Char* text = NULL;
	UInt16	lines = 0;
	WinDirectionType dir = winDown;
	UInt16		scrollPos		= 0;
	UInt16		textHeight	= 0;
	UInt16		fieldHeight	= 0;


	frmP = FrmGetActiveForm();

	switch (event->eType) 
		{
   case ctlSelectEvent:
			switch (event->data.ctlSelect.controlID) 
      {
				case buttonHistoryDone:
					FldSetTextHandle(GetObjectPtr(fldHistory), NULL);
					//FrmReturnToForm(frmBrowser);
					//if (memoH)
					//	MemHandleFree (memoH);
					FrmReturnToForm(0);
				handled = true;
	        	break;

				case buttonClearHistory:
					//FldSetTextHandle(GetObjectPtr(fldHistory), NULL);
					//if (memoH)
					//	MemHandleFree (memoH);
					ClearHistory();
					HistoryFormInit(frmP);
					FldDrawField(GetObjectPtr(fldHistory));
				handled = true;
				break;
	    }

			break;
			
		case frmOpenEvent:
			frmP = FrmGetActiveForm();
			HistoryFormInit (frmP);
			FrmDrawForm (frmP);
			handled = true;
			break;

		case frmCloseEvent:
			FldSetTextHandle(GetObjectPtr(fldHistory), NULL);
			//if (memoH)
			//	MemHandleFree (memoH);
		handled = true;
		break;

    case sclRepeatEvent:
    	if(event->data.sclExit.value > event->data.sclRepeat.newValue)
    	{
    		lines = event->data.sclExit.value - event->data.sclRepeat.newValue;
    		dir = winUp;
    	}
			else
			{
    		lines = event->data.sclExit.newValue - event->data.sclRepeat.value;
    		dir = winDown;
			}
			 	
			FldScrollField(GetObjectPtr(fldHistory), lines, dir);
			UpdateScrollers();
			
			break;

		case fldChangedEvent:

			UpdateScrollers();
		
			handled = true;
			break;

		case keyDownEvent:
			switch (event->data.keyDown.chr)
			{
				case pageUpChr:
					FldGetScrollValues (GetObjectPtr(fldHistory), &scrollPos, &textHeight, &fieldHeight);				
					FldScrollField(GetObjectPtr(fldHistory), fieldHeight - 1, winUp);
					UpdateScrollers();

					handled = true;
					break;

				case pageDownChr:
					FldGetScrollValues (GetObjectPtr(fldHistory), &scrollPos, &textHeight, &fieldHeight);					
					FldScrollField(GetObjectPtr(fldHistory), fieldHeight - 1, winDown);
					UpdateScrollers();

					handled = true;
					break;
			}
			break;

		default:
			break;
		
		}
	
	return handled;
}

/***********************************************************************
 *
 *	Inits the History form
 *
 *	Paramaters:		frmP : FormPtr	- ptr to history form
 *
 *	Returns:			Nothing
 *
 ***********************************************************************/
static void HistoryFormInit(FormPtr frmP)
{
  DmOpenRef MemoDB;
	Char			title[40];
//	MemHandle  memoH				= NULL;
	Char*	sMemo				= NULL;
	UInt16	index				= 0;
	Boolean	stop				= false;
	Boolean	bGotRecord	= false;

  MemoDB = DmOpenDatabaseByTypeCreator('DATA', 'memo', dmModeReadWrite);
  
  
  if (MemoDB)
	{
		stop = false;
		
		while(!stop)
		{
			memoH = DmQueryNextInCategory (MemoDB, &index, dmUnfiledCategory);
			
			if(!memoH)
			{
				stop = true;
			}
			else
			{
				sMemo = MemHandleLock(memoH);
				
				if(!sMemo)
				{
					stop = true;
				}
				else
				{
					GetMemoTitle(sMemo, title);
					if(StrCompare(title, "WAPUniverse History") == 0)
					{
						bGotRecord = true;
						stop = true;
					}
				
					MemHandleUnlock(memoH);
				}
			}
			
			index++;
		}
		
		index--;

		if(!bGotRecord)
		{
			FrmShowObject (frmP, FrmGetObjectIndex(frmP, labelNoHistory));
			FrmHideObject (frmP, FrmGetObjectIndex(frmP, buttonClearHistory));
		}
		else
		{
			memoH = DmQueryRecord(MemoDB, index);
			
			if(memoH)
			{
				FldSetTextHandle(GetObjectPtr(fldHistory), memoH);
			}
		}
		
		UpdateScrollers();
		
		DmCloseDatabase(MemoDB);
	}
}


/***********************************************************************
 *
 *	Updates the scollers for the log text
 *
 *	Paramaters:		None
 *
 *	Returns:			Nothing
 *
 ***********************************************************************/
static void UpdateScrollers()
{
	UInt16		scrollPos		= 0;
	UInt16		textHeight	= 0;
	UInt16		fieldHeight	= 0;
	UInt16		maxpos			= 0;	

	FldGetScrollValues (GetObjectPtr(fldHistory), &scrollPos, &textHeight, &fieldHeight);

	if(textHeight > fieldHeight)
	{
		maxpos = textHeight - fieldHeight - 1;
	}
	else
	{
		maxpos = 0;
	}

	SclSetScrollBar (GetObjectPtr(scrollHistory), scrollPos, 0, maxpos, fieldHeight);
}