Update ScePaf

9 files changed, 1174 insertions, 181 deletions

diff --git a/include/user/paf.h b/include/user/paf.h
index b0cc028..944616d 100644
--- a/include/user/paf.h
+++ b/include/user/paf.h
@@ -59,9 +59,11 @@ namespace paf {
 
 	namespace graphics {
 
+		class TextObj;
 		class MemoryPool;
 		class Surface;
 		class Texture;
+		class DrawQueue;
 	}
 
 	namespace datetime {
@@ -102,6 +104,7 @@ namespace paf {
 #include <paf/misc.h>
 #include <paf/resource.h>
 #include <paf/thread.h>
+#include <paf/lowlayer.h>
 
 #endif /* _VDSUITE_USER_PAF_H */
 
diff --git a/include/user/paf/common.h b/include/user/paf/common.h
index e3ecda5..67d6e5e 100644
--- a/include/user/paf/common.h
+++ b/include/user/paf/common.h
@@ -10,27 +10,12 @@
 
 namespace paf {
 
-	class String;
-	class WString;
-
 	namespace widget {
 		class Widget;
 	}
 
-	namespace common {
-
-		enum CesFlags
-		{
-			AllowIllegalCode	= 0x2,
-			AllowOutOfCodeRange	= 0x4,
-			AllowInvalidEncode	= 0x8,
-			AllowSrcBufferEnd	= 0x10
-		};
-
-		static paf::widget::Widget *WidgetStateTransition(SceFloat32 delay, paf::widget::Widget *widget, SceUInt32 animationId, SceBool disableOnEnd, SceBool skipAnimation);
-		static paf::widget::Widget *WidgetStateTransitionReverse(SceFloat32 delay, paf::widget::Widget *widget, SceUInt32 animationId, SceBool disableOnEnd, SceBool skipAnimation);
-	}
-
+	class String;
+	class WString;
 
 	class String
 	{
@@ -46,7 +31,7 @@ namespace paf {
 
 		~String()
 		{
-			if (length != 0 && *data != 0)
+			if (length != 0 && data != &null)
 				delete data;
 		}
 
@@ -60,65 +45,150 @@ namespace paf {
 
 		SceSSize ToWString(paf::WString *dst, SceUInt32 flags);
 
-		String *Set(const char *s, SceSize srcLength)
+		SceVoid MemsizeFormat(SceSize memsize);
+
+		SceVoid Setf(const char *format, ...);
+
+		SceVoid Set(const char* c, SceInt32 len)
 		{
-			if (data == s)
-				return this;
+			Clear();
 
-			if (*data != 0)
-				delete data;
+			if (!len)
+			{
+				SetEmpty();
 
-			if (srcLength == 0 || s == SCE_NULL || s[0] == 0) {
-				String();
-				return this;
+				return;
 			}
 
-			data = new char[srcLength + 1];
-			length = srcLength;
-			sce_paf_memcpy(data, s, length);
-			data[length] = 0;
+			Copy(c, len);
+		}
 
-			return this;
-		};
+		SceVoid Set(const char* c)
+		{
+			SceInt32 len = sce_paf_strlen(c);
+
+			Clear();
+
+			if (!len)
+			{
+				SetEmpty();
+
+				return;
+			}
+
+			Copy(c, len);
+		}
+
+		SceVoid Clear()
+		{
+			if (IsEmpty())
+			{
+				return;
+			}
+
+			delete data;
 
-		String *Set(const char *s)
+			SetEmpty();
+		}
+
+		String *operator=(const char* c)
 		{
-			Set(s, sce_paf_strlen(s));
+			Clear();
+
+			Copy(c, sce_paf_strlen(c));
 			return this;
-		};
+		}
 
 		String *operator=(const String *s)
 		{
-			if (data == s->data)
-				return this;
+			Clear();
 
-			if (s->length == 0) {
-				String();
-				return this;
+			Copy(s->data, s->length);
+			return this;
+		}
+
+		String operator+(const String *s) const
+		{
+			SceInt32 len1 = length;
+			SceInt32 len2 = s->length;
+
+			if (!len1 && !len2)
+			{
+				String ret;
+				return ret;
 			}
 
-			data = new char[s->length + 1];
-			length = s->length;
-			sce_paf_memcpy(data, s->data, s->length + 1);
+			char* newptr = new char[len1 + len2 + 1];
 
-			return this;
+			if (newptr == SCE_NULL)
+			{
+				String ret;
+				return ret;
+			}
+
+			sce_paf_memcpy(newptr, data, sizeof(char) * len1);
+			sce_paf_memcpy(&newptr[len1], s->data, sizeof(char) * (s->length + 1));
+
+			String ret(newptr, len1 + len2);
+			delete newptr;
+
+			return ret;
 		}
 
-		String *operator+(const String *s) const
+		String operator+(const char* c) const
 		{
-			String *newStr = new String;
+			SceInt32 len1 = length;
+			SceInt32 len2 = sce_paf_strlen(c);
 
-			if (!length && !s->length)
+			char* newptr = new char[len1 + len2 + 1];
+
+			if (newptr == SCE_NULL)
 			{
-				return newStr;
+				String ret;
+				return ret;
 			}
 
-			newStr->data = new char[s->length + length + 1];
-			newStr->length = s->length + length;
-			sce_paf_memcpy(newStr->data, data, length);
-			sce_paf_memcpy(&newStr->data[length], s->data, s->length + 1);
-			newStr->data[newStr->length] = 0;
-			return newStr;
+			sce_paf_memcpy(newptr, data, sizeof(char) * len1);
+			sce_paf_memcpy(&newptr[len1], c, sizeof(char) * (len2 + 1));
+
+			String ret(newptr, len1 + len2);
+			delete newptr;
+
+			return ret;
+		}
+
+		String *operator+=(const String *s)
+		{
+			char* newptr = SCE_NULL;
+			SceInt32 len1 = length;
+
+			newptr = new char[length + s->length + 1];
+
+			sce_paf_memcpy(newptr, data, len1);
+			sce_paf_memcpy(&newptr[len1], s->data, s->length + 1);
+
+			Clear();
+			Set(newptr, len1 + s->length);
+			delete newptr;
+
+			return this;
+		}
+
+		String *operator+=(const char* c)
+		{
+			SceInt32 len1 = length;
+			SceInt32 len2 = sce_paf_strlen(c);
+
+			char* newptr = new char[len1 + len2 + 1];
+
+			sce_paf_memcpy(newptr, data, len1);
+			sce_paf_memcpy(&newptr[len1], c, len2 + 1);
+
+			Clear();
+			Set(newptr, len1 + len2);
+			delete newptr;
+
+			return this;
 		}
 
 		SceBool operator==(const String *s) const
@@ -126,20 +196,90 @@ namespace paf {
 			if (s->length != length)
 				return SCE_FALSE;
 
-			if (!sce_paf_strncmp(s->data, data, length))
+			if (sce_paf_strncmp(data, s->data, length))
+				return SCE_FALSE;
+
+			return SCE_TRUE;
+		}
+
+		SceBool operator==(const char* rc) const
+		{
+			if (sce_paf_strlen(rc) != length)
+				return SCE_FALSE;
+
+			if (sce_paf_strncmp(data, rc, length))
+				return SCE_FALSE;
+
+			return SCE_TRUE;
+		}
+
+		SceBool operator<(const String *s) const
+		{
+			return sce_paf_strcmp(data, s->data) < 0;
+		}
+
+		SceBool operator<(const char* c) const
+		{
+			return sce_paf_strcmp(data, c) < 0;
+		}
+
+		SceBool operator>(const String *s) const
+		{
+			return sce_paf_strcmp(data, s->data) > 0;
+		}
+
+		SceBool operator>(const char* c) const
+		{
+			return sce_paf_strcmp(data, c) > 0;
+		}
+
+		String *Append(const char* c, SceInt32 len2)
+		{
+			SceInt32 len1 = length;
+
+			char *newptr = new char[len1 + len2 + 1];
+
+			sce_paf_memcpy(newptr, data, len1);
+			sce_paf_memcpy(&newptr[len1], c, len2);
+
+			Clear();
+			Set(newptr, len1 + len2);
+			delete newptr;
+
+			return this;
+		}
+
+		SceVoid Copy(const char* c, SceInt32 cLength)
+		{
+			if (!cLength)
+			{
+				return;
+			}
+
+			length = cLength;
+
+			data = new char[length + 1];
+
+			sce_paf_memcpy(data, c, cLength);
+			data[cLength] = 0;
+		}
+
+		SceBool IsEmpty() const
+		{
+			if (data == &null && length == 0)
 				return SCE_TRUE;
 			else
 				return SCE_FALSE;
 		}
 
-		SceVoid Clear()
+		SceVoid SetEmpty()
 		{
-			if (length != 0 && data != SCE_NULL) {
-				delete data;
-				String();
-			}
+			data = &null;
+			length = 0;
 		}
 
+		static char null;
+
 		char *data;
 		SceSize length;
 
@@ -153,12 +293,12 @@ namespace paf {
 	{
 	public:
 
-		WString() : data(SCE_NULL), length(0)
+		WString() : data(&null), length(0)
 		{
 
 		}
 
-		WString(const SceWChar16 *s, SceSize srcLength) : data(SCE_NULL), length(0)
+		WString(const SceWChar16 *s, SceSize srcLength) : data(&null), length(0)
 		{
 			if (srcLength == 0 || s == SCE_NULL || s[0] == 0) {
 				return;
@@ -172,7 +312,7 @@ namespace paf {
 			return;
 		}
 
-		WString(const SceWChar16 *s) : data(SCE_NULL), length(0)
+		WString(const SceWChar16 *s) : data(&null), length(0)
 		{
 			SceSize srcLength = sce_paf_wcslen((wchar_t*)s);
 
@@ -190,7 +330,7 @@ namespace paf {
 
 		~WString()
 		{
-			if (length != 0 && data != SCE_NULL)
+			if (length != 0 && data != &null)
 				delete data;
 		}
 
@@ -209,11 +349,11 @@ namespace paf {
 			if (data == s)
 				return this;
 
-			if (data != SCE_NULL)
+			if (data != &null)
 				delete data;
 
 			if (srcLength == 0 || s == SCE_NULL || s[0] == 0) {
-				data = SCE_NULL;
+				data = &null;
 				length = 0;
 				return this;
 			}
@@ -232,13 +372,29 @@ namespace paf {
 			return this;
 		};
 
+		WString *Append(const SceWChar16 *c, SceInt32 len2)
+		{
+			SceInt32 len1 = length;
+
+			SceWChar16 *newptr = new SceWChar16[len1 + len2 + 1];
+
+			sce_paf_wmemcpy((wchar_t *)newptr, (wchar_t *)data, len1);
+			sce_paf_wmemcpy((wchar_t *)&newptr[len1], (wchar_t *)c, len2);
+
+			Clear();
+			Set(newptr, len1 + len2);
+			delete newptr;
+
+			return this;
+		}
+
 		WString *operator=(const WString *s)
 		{
 			if (data == s->data)
 				return this;
 
 			if (s->length == 0) {
-				data = SCE_NULL;
+				data = &null;
 				length = 0;
 				return this;
 			}
@@ -280,13 +436,15 @@ namespace paf {
 
 		SceVoid Clear()
 		{
-			if (length != 0 && data != SCE_NULL) {
+			if (length != 0 && data != &null) {
 				delete data;
 				length = 0;
-				data = SCE_NULL;
+				data = &null;
 			}
 		}
 
+		static SceWChar16 null;
+
 		SceWChar16 *data;
 		SceSize length;
 
@@ -295,21 +453,49 @@ namespace paf {
 		SceUInt32 m_work;
 	};
 
+	class SWString
+	{
+	public:
+
+		SWString();
+
+		SWString(const char *str);
+
+		SWString(const SceWChar16 *str);
+
+		SWString(String *src);
+
+		SWString(WString *src);
+
+		~SWString();
+
+		String string;
+		WString wstring;
+	};
+
 	namespace common {
 
 		class Utils
 		{
 		public:
 
-			typedef void(*MainThreadTaskEntryFunction)(void *pArgBlock);
-
-			Utils();
+			enum CesFlags
+			{
+				AllowIllegalCode = 0x2,
+				AllowOutOfCodeRange = 0x4,
+				AllowInvalidEncode = 0x8,
+				AllowSrcBufferEnd = 0x10
+			};
 
-			~Utils();
+			typedef void(*MainThreadTaskEntryFunction)(void *pArgBlock);
 
 			static SceVoid AddMainThreadTask(MainThreadTaskEntryFunction entry, ScePVoid pArgBlock);
 
 			static SceVoid RemoveMainThreadTask(MainThreadTaskEntryFunction entry, ScePVoid pArgBlock);
+
+			static paf::widget::Widget *WidgetStateTransition(SceFloat32 animationSpeed, paf::widget::Widget *widget, SceUInt32 animationId, SceBool disableOnEnd, SceBool skipAnimation);
+
+			static paf::widget::Widget *WidgetStateTransitionReverse(SceFloat32 animationSpeed, paf::widget::Widget *widget, SceUInt32 animationId, SceBool disableOnEnd, SceBool skipAnimation);
 		};
 
 	}
diff --git a/include/user/paf/graphics.h b/include/user/paf/graphics.h
index 101a94a..4338e43 100644
--- a/include/user/paf/graphics.h
+++ b/include/user/paf/graphics.h
@@ -14,10 +14,74 @@ namespace paf {
 
 	namespace graphics {
 
+		class TextObj
+		{
+		public:
+
+			//ScePafGraphics_F201F98D c1
+			//ScePafGraphics_29013890 c2
+			TextObj(SceInt32 *flags);
+
+			//ScePafGraphics_FA7B17C2 d2
+			//ScePafGraphics_8021A2B3 d0
+			//ScePafGraphics_919B8983 d1
+			virtual ~TextObj();
+
+			virtual SceBool ContainsType(const char *pTypeName);
+			virtual char *GetType();
+			virtual SceInt32 unkFun_08();
+			virtual SceInt32 unkFun_0C(); // D0, why is it here?
+			virtual SceInt32 unkFun_10();
+			virtual SceInt32 unkFun_14();
+			virtual SceInt32 unkFun_18(); // test
+			virtual SceInt32 unkFun_1C();
+			virtual SceInt32 unkFun_20();
+			virtual SceInt32 unkFun_24();
+			virtual SceInt32 unkFun_28();
+			virtual SceInt32 unkFun_2C();
+			virtual SceInt32 unkFun_30();
+			virtual SceInt32 unkFun_34();
+			virtual SceInt32 unkFun_38(); // test
+			virtual SceInt32 unkFun_3C(); // test
+			virtual SceInt32 unkFun_40();
+			virtual SceInt32 unkFun_44();
+
+			//ScePafGraphics_1BDA4425
+			SceInt32 GetLabel(WString *pText);
+
+			//ScePafGraphics_AE415C90
+			SceInt32 SetLabel(WString *pText);
+
+			//ScePafGraphics_DC2C405E
+			SceInt32 SetPlaceholderLabel(WString *pText);
+
+			//ScePafGraphics_D3BEDF03
+			SceInt32 GetPlaceholderLabel(WString *pText);
+
+			SceInt32 GetLength(SceUInt32 *pLength);
+
+			//ScePafGraphics_67094D42
+			SceInt32 GetDataAndLength(SceWChar16 **ppData, SceUInt32 *pLength);
+
+			static SceInt32 *s_defaultTextObjFlags;
+
+		private:
+
+			SceUChar8 unk_00[0x58];
+
+		};
+
 		class MemoryPool
 		{
 		public:
 
+			enum MemoryType
+			{
+				MemoryType_UserNC,
+				MemoryType_CDRAM,
+				MemoryType_Shared,
+			};
+
 			class InitParam
 			{
 			public:
@@ -40,17 +104,10 @@ namespace paf {
 			virtual int unkf2();
 			virtual int unkf3();
 
-			enum MemoryType
-			{
-				MemoryType_UserNC,
-				MemoryType_CDRAM,
-				MemoryType_Shared,
-			};
-
 			enum MemoryTypeSpecial
 			{
 				MemoryTypeSpecial_Unused,
-				MemoryTypeSpecial_Unk0xCF08060,
+				MemoryTypeSpecial_Tool,
 				MemoryTypeSpecial_Phycont
 			};
 
@@ -59,7 +116,7 @@ namespace paf {
 				GpuMapType_Normal,
 				GpuMapType_VertexUsse,
 				GpuMapType_FragmentUsse,
-				GpuMapType_NoMap,
+				GpuMapType_NoMap
 			};
 
 			class MemBlockOptParam
@@ -90,6 +147,47 @@ namespace paf {
 		{
 		public:
 
+			class GxmTexture
+			{
+			public:
+
+				SceGxmTexture *texture;
+				SceInt32 unk_04;
+			};
+
+			class Base
+			{
+			public:
+
+				Base *prev;
+				Base *next;
+				SceInt32 lock;
+				SceUInt16 width;
+				SceUInt16 height;
+				SceInt32 texType; // linear/swizzled/tiled
+				SceInt32 unk_14;
+				SceInt32 unk_18;
+				SceUInt16 widthAligned;
+				SceUInt16 heightAligned;
+				SceFloat32 xScale;
+				SceFloat32 yScale;
+				SceInt32 pixels;
+				SceUInt16 width3;
+				SceUInt16 unk_3e;
+				SceInt32 unk_30;
+				GxmTexture *texture;
+				SceGxmTextureFilter magFilter;
+				SceGxmTextureFilter minFilter;
+				SceGxmTextureFilter mipFilter;
+				SceGxmTextureAddrMode uaddrMode;
+				SceGxmTextureAddrMode vaddrMode;
+				SceUInt32 lodBias;
+				SceInt32 unk_50;
+				SceInt32 unk_54;
+				SceInt32 unk_58;
+				ScePVoid gxmData;
+			};
+
 			Surface(MemoryPool *pMemPool, SceUInt32 width, SceUInt32 height, SceUInt32 format, SceUInt32 orderType, SceInt32 a7, SceUInt32 numLevel, SceInt32 a9);
 
 			virtual ~Surface();
@@ -109,9 +207,31 @@ namespace paf {
 
 			void operator delete(void*);
 
+			//ScePafGraphics_E57728C4
+			static SceInt32 Copy(Surface *dst, SceInt32 a2, Surface *src, SceUInt32 srcOrderType, SceSize copySize, SceInt32 a6 = -1);
+
+			SceInt32 GetLock();
+
+			//ScePafGraphics_879B135D
+			ScePVoid GetGxmData();
+
+			//ScePafGraphics_D075A824
+			SceInt32 ReplaceData(SceGxmTexture **tex, const ScePVoid data);
+
+			//ScePafGraphics_3B5327DF
+			SceUInt32 GetPixelCount();
+
+			//ScePafGraphics_804E92B1
+			SceInt32 ApplyFilters();
+
+			SceInt32 texFormat;
+			SceInt32 unk_08;
+			SceInt32 unk_0C;
+			Base base;
+
 		private:
 
-			SceUChar8 m_work[0x44];
+			SceUChar8 m_work[0x24];
 
 		};
 
@@ -123,14 +243,145 @@ namespace paf {
 
 			~Texture() { };
 
+			static SceVoid CreateFromFile(Texture *tex, MemoryPool *memPool, paf::Misc::OpenResult *file, ScePVoid fwOpt = SCE_NULL);
+
+			static SceVoid CreateFromMemory(Texture *tex, MemoryPool *memPool, ScePVoid ptr, SceInt32 unused_1, SceSize size, SceInt32 unused_2 = 0, ScePVoid fwOpt = SCE_NULL);
+
 			Surface *texSurface;
 
-		private:
+			ScePVoid unk;
+		};
+
+		class FwGraphicsContext
+		{
+		public:
+
+			class ShaderPatcher {
+			public:
+
+				SceGxmShaderPatcher *shaderPatcher;
+
+				//more?
+			};
+
+			enum Target
+			{
+				Target_None,
+				Target_Front,
+				Target_Back
+			};
+
+			static FwGraphicsContext *GetFwGraphicsContext();
+
+			//ScePafGraphics_E4B3B1D2
+			SceVoid Finish();
+
+			//ScePafGraphics_751FC8E6
+			SceInt32 BeginScene(const SceGxmRenderTarget *renderTarget, SceGxmSyncObject *fragmentSyncObject, const SceGxmColorSurface *colorSurface, const SceGxmDepthStencilSurface *depthStencilSurface, SceUInt32 flags);
+
+			//ScePafGraphics_D5E30C64
+			SceInt32 EndScene(const SceGxmNotification *vertexNotification, const SceGxmNotification *fragmentNotification);
+
+			//ScePafGraphics_6E7B77AC
+			SceVoid SetWClampValue(float clampValue);
+
+			//ScePafGraphics_84619C66
+			SceVoid SetPolygonMode(SceGxmPolygonMode mode, SceUInt32 target);
+
+			//ScePafGraphics_D9EA2729
+			SceVoid SetPointLineWidth(SceFloat32 width, SceUInt32 target);
+
+			//ScePafGraphics_9EAD43B5
+			SceVoid SetPointLineWidth2(SceFloat32 width, SceUInt32 target);
+
+			//ScePafGraphics_DAC195AC
+			SceVoid SetStencilFunc(SceGxmStencilFunc func, SceGxmStencilOp stencilFail, SceGxmStencilOp depthFail, SceGxmStencilOp depthPass, uint8_t compareMask, uint8_t writeMask, SceUInt32 target);
+
+			//ScePafGraphics_722A4987
+			SceVoid SetCullMode(SceGxmCullMode mode);
+
+			//ScePafGraphics_7EC1D482
+			SceVoid SetDepthFunc(SceGxmDepthFunc depthFunc, SceUInt32 target);
+
+			//ScePafGraphics_2AE23377
+			SceVoid SetDepthWriteEnable(SceGxmDepthWriteMode enable, SceUInt32 target);
 
-			SceUChar8 unk[0x4];
+			//ScePafGraphics_5F8FDEC7
+			SceVoid ResetParam(SceUInt32 targetParam);
 
+			SceUChar8 unk_000[0x61C];
+
+			ShaderPatcher *shaderPatcher;
+
+			SceUChar8 unk_620[0x6C];
+
+			SceGxmContext *gxmContext;
+
+			SceUChar8 unk_690[0xD4];
+
+			SceUInt8 frontDepthWriteEnabled;
+			SceUInt8 backDepthWriteEnabled;
+
+			SceUInt16 unk_766;
+
+			SceGxmCullMode cullMode;
 		};
 
+		class DrawQueue
+		{
+		public:
+
+			class Item;
+
+			class Request
+			{
+			public:
+
+				typedef void(*RequestEntryFunction)(Item *job);
+
+				Item *job;
+				SceInt32 unk_04;
+				SceInt32 unk_08;
+				RequestEntryFunction entry;
+
+			};
+
+			class Item
+			{
+			public:
+
+				Item() { };
+
+				virtual ~Item() { };
+
+				virtual SceVoid DrawCB() = 0;
+
+				virtual SceVoid UnkCB2() = 0;
+
+				virtual SceVoid UnkCB3() = 0;
+
+				Request *req;
+
+			private:
+
+				SceUChar8 m_work[0x0C];
+
+			};
+
+			class ItemParam
+			{
+			public:
+
+				Item *item;
+				Request *request;
+			};
+
+			DrawQueue() { };
+
+			~DrawQueue() { };
+
+			SceInt32 SetDrawJob(ItemParam *queueItemParam);
+		};
 	}
 }
 
diff --git a/include/user/paf/lowlayer.h b/include/user/paf/lowlayer.h
new file mode 100644
index 0000000..f92d871
--- /dev/null
+++ b/include/user/paf/lowlayer.h
@@ -0,0 +1,25 @@
+/*
+	Vita Development Suite Libraries
+*/
+
+#ifndef _VDSUITE_USER_PAF_LOWLAYER_H
+#define _VDSUITE_USER_PAF_LOWLAYER_H
+
+#include <libdeflt.h>
+#include <kernel.h>
+#include <paf/common.h>
+
+namespace paf {
+	namespace lowlayer {
+
+		class Deflt
+		{
+		public:
+
+			static SceInt32 Decompress(ScePVoid pDst, SceUInt32 uiBufSize, const ScePVoid pSrcDeflate, const ScePVoid *ppNext);
+		};
+
+	}
+}
+
+#endif /* _VDSUITE_USER_PAF_LOWLAYER_H */
diff --git a/include/user/paf/misc.h b/include/user/paf/misc.h
index bf21a65..18925e0 100644
--- a/include/user/paf/misc.h
+++ b/include/user/paf/misc.h
@@ -12,7 +12,11 @@
 
 namespace paf {
 
-	static SceBool IsDolce();
+	namespace graphics {
+		class Texture;
+	}
+
+	class Allocator;
 
 	namespace datetime {
 
@@ -87,50 +91,89 @@ namespace paf {
 
 	}
 
+	class Http
+	{
+	public:
+
+		Http();
+
+		~Http() {};
+
+		SceVoid SetUrl(const char *url);
+
+		SceVoid SetUrl(paf::String *url);
+
+		SceInt32 SetUnk(SceInt32 a1, SceInt32 a2);
+
+	private:
+
+		SceUChar8 m_work[0xB4];
+
+	};
+
 	namespace io {
 
 		enum Error
 		{
-			SCE_PAF_ERROR_MISC_IO_INVALID_POINTER = 0x80AF5901
+			SCE_PAF_ERROR_MISC_IO_INVALID_POINTER = 0x80AF5901,
+			SCE_PAF_ERROR_MISC_IO_INVALID_ARGUMENT = 0x80AF5002,
+			SCE_PAF_ERROR_MISC_IO_OUT_OF_MEMORY = 0x80AF5003,
+			SCE_PAF_ERROR_MISC_IO_HTTP_NOT_SUPPORTED = 0x80AF5004,
+			SCE_PAF_ERROR_MISC_IO_MEM_NOT_SUPPORTED = 0x80AF5005,
+			SCE_PAF_ERROR_MISC_IO_FILE_NOT_FOUND = 0x80AF5022
 		};
 
-		class File
+		enum Type
+		{
+			Type_Dir,
+			Type_File,
+			Type_Reg,
+			Type_Lnk
+		};
+
+		class AsyncResult
 		{
 		public:
 
-			class AsyncResult
-			{
-			public:
+			SceInt32 result;
+			SceInt32 unk_04;
+		};
 
-				SceInt32 result;
-				SceInt32 unk_04;
-			};
+		class File
+		{
+		public:
 
 			File();
 
 			virtual ~File();
 
-			virtual SceInt32 Open(const char *filename, int flag, SceIoMode mode);
+			virtual SceInt32 Open(const char *filename, SceInt32 flag, SceIoMode mode);
 			virtual SceInt32 Close();
-			virtual SceInt32 Read(void *buf, SceSize nbyte);
-			virtual SceInt32 Write(const void *buf, SceSize nbyte);
-			virtual SceInt32 Lseek(SceOff offset, int whence);
+			virtual SceInt32 Read(ScePVoid buf, SceSize nbyte);
+			virtual SceInt32 Write(const ScePVoid buf, SceSize nbyte);
+			virtual SceOff   Lseek(SceOff offset, SceInt32 whence, SceIoAsyncParam* asyncParam = SCE_NULL);
 			virtual SceInt32 Sync();
-			virtual SceInt32 OpenAsync(const char *filename, int flags, SceMode mode);
+			virtual SceInt32 OpenAsync(const char *filename, SceInt32 flag, SceMode mode);
 			virtual SceInt32 CloseAsync();
-			virtual SceInt32 ReadAsync(void *buf, SceSize nbyte);
-			virtual SceInt32 WriteAsync(const void *buf, SceSize nbyte);
-			virtual SceInt32 LseekAsync(SceInt32 a1, int whence, SceIoAsyncParam* asyncParam);
+			virtual SceInt32 ReadAsync(ScePVoid buf, SceSize nbyte);
+			virtual SceInt32 WriteAsync(const ScePVoid buf, SceSize nbyte);
+			virtual SceInt32 LseekAsync(SceOff offset, SceInt32 whence, SceIoAsyncParam* asyncParam);
 			virtual SceInt32 SyncAsync();
 			virtual SceInt32 WaitAsync(AsyncResult *pResult);
 			virtual SceInt32 PollAsync(AsyncResult *pResult);
-			virtual SceBool IsOpened();
-			virtual SceInt32 unkFun_44();
+			virtual SceBool  IsOpened();
+			virtual SceBool unkFun_44();
 			virtual SceInt32 CancelAsync();
-			virtual SceOff GetSize();
-			virtual SceInt32 GetStat(ScePVoid pafStat);
+			virtual SceOff   GetSize();
+			virtual SceInt32 GetStat(SceIoStat *stat);
 			virtual SceInt32 SetPriority(SceUInt32 ioPriority);
 
+			static SceInt32 Rename(const char *oldname, const char *newname);
+
+			static SceInt32 Remove(const char *path);
+
+			static SceOff GetSize(const char *path);
+
 		private:
 
 			SceUChar8 m_work[0x2C];
@@ -145,7 +188,7 @@ namespace paf {
 			{
 			public:
 
-				SceInt32 type;
+				Type type;
 				paf::String name;
 				SceInt32 size;
 				SceUInt32 creationYear;
@@ -165,26 +208,207 @@ namespace paf {
 
 		};
 
-		static SceInt32 SetDefaultPriority(SceUInt32 ioPriority);
+		class Mem
+		{
+		public:
 
-		static SceBool Exists(const char *path);
+			virtual SceInt32 unkFun_00();
+			virtual ScePVoid GetMembase();
+			virtual SceSize GetSize();
 
-		static SceBool IsDir(const char *path);
+			virtual ~Mem();
 
-		static SceInt32 Remove(const char *path);
+		private:
 
-		static SceInt32 RemoveRecursive(const char *path);
+			Mem();
 
-		static SceInt32 Mkdir(const char *dirname, SceIoMode mode);
+			SceUChar8 m_work[0x0C];
+		};
+
+		class Stat
+		{
+		public:
+
+			static SceInt32 GetStat(const char *path, Stat *buf);
+
+			static SceBool IsFileOrDir(const char *path);
+
+			static SceBool IsFile(const char *path);
+
+			static SceBool IsDir(const char *path);
+
+			SceIoMode			st_mode;
+			SceUInt32			st_attr;
+			SceOff				st_size;
+			datetime::DateTime	ctime;
+			SceUChar8			pad1[3];
+			datetime::DateTime	atime;
+			SceUChar8			pad2[3];
+			datetime::DateTime	mtime;
+		};
+
+		class Misc
+		{
+		public:
+
+			static SceInt32 SetDefaultPriority(SceUInt32 ioPriority);
+
+			static SceBool Exists(const char *path);
+
+			static SceBool IsDir(const char *path);
 
-		static SceInt32 MkdirRWSYS(const char *dirname);
+			static SceOff GetSize(const char *path);
 
-		//dot-separated path list
-		static SceInt32 MkdirMulti(const char *dirnameList, SceIoMode mode);
+			static SceInt32 Rename(const char *oldname, const char *newname);
 
-		static SceInt32 MkdirMultiRWSYS(const char *dirnameList);
+			static SceInt32 Remove(const char *path);
+
+			static SceInt32 RemoveAny(const char *path);
+
+			static SceInt32 RemoveRecursive(const char *path);
+
+			static SceInt32 Mkdir(const char *dirname, SceIoMode mode);
+
+			static SceInt32 MkdirRWSYS(const char *dirname);
+
+			//dot-separated path list
+			static SceInt32 CreateRecursive(const char *dirnameList, SceIoMode mode);
+
+			static SceInt32 CreateRecursiveRWSYS(const char *dirnameList);
+		};
 	}
 
+	class LocalFile
+	{
+	public:
+
+		class OpenParam
+		{
+		public:
+
+			SceUInt32 ioType;
+			char *filename;
+			SceInt32 flag;
+			SceIoMode mode;
+		};
+
+		LocalFile();
+
+		LocalFile(paf::Allocator *allocator);
+
+		virtual SceInt32 GetType();
+		virtual SceInt32 unkFun_04();
+		virtual SceInt32 GetSize();
+		virtual SceInt32 Open(OpenParam *param);
+		virtual SceInt32 OpenAsync(OpenParam *param);
+		virtual SceInt32 Close();
+		virtual SceInt32 CloseAsync();
+		virtual SceBool  IsOpened();
+		virtual SceBool  unkFun_20();
+		virtual SceInt32 CancelAsync();
+		virtual SceInt32 Read(ScePVoid buf, SceSize nbyte);
+		virtual SceInt32 ReadAsync(ScePVoid buf, SceSize nbyte);
+		virtual SceInt32 Write(const ScePVoid buf, SceSize nbyte);
+		virtual SceInt32 WriteAsync(const ScePVoid buf, SceSize nbyte);
+		virtual SceOff   Lseek(SceOff offset, SceInt32 whence, SceIoAsyncParam* asyncParam = SCE_NULL);
+		virtual SceInt32 LseekAsync(SceOff offset, SceInt32 whence, SceIoAsyncParam* asyncParam);
+		virtual SceInt32 Sync();
+		virtual SceInt32 SyncAsync();
+		virtual SceInt32 WaitAsync(io::AsyncResult *pResult);
+		virtual SceInt32 PollAsync(io::AsyncResult *pResult);
+		virtual SceInt32 GetStat(SceIoStat *stat);
+		virtual SceInt32 SetPriority(SceUInt32 ioPriority);
+
+		virtual ~LocalFile();
+
+	private:
+
+		SceUChar8 m_work[0x2C];
+	};
+
+	class MemFile
+	{
+	public:
+
+		class OpenParam
+		{
+		public:
+
+			SceUInt32 ioType;
+			ScePVoid ptr;
+			SceSize size;
+		};
+
+		MemFile();
+
+		virtual SceInt32 GetType();
+		virtual SceInt32 unkFun_04();
+		virtual SceUInt64 GetSize();
+		virtual SceInt32 Open(OpenParam *param);
+		virtual SceInt32 OpenAsync(OpenParam *param);
+		virtual SceInt32 Close();
+		virtual SceInt32 CloseAsync();
+		virtual SceBool  IsOpened();
+		virtual SceBool  unkFun_20();
+		virtual SceInt32 CancelAsync();
+		virtual SceInt32 Read(ScePVoid buf, SceSize nbyte);
+		virtual SceInt32 ReadAsync(ScePVoid buf, SceSize nbyte);
+		virtual SceInt32 Write(const ScePVoid buf, SceSize nbyte);
+		virtual SceInt32 WriteAsync(const ScePVoid buf, SceSize nbyte);
+		virtual SceInt32 Lseek(SceOff offset, SceInt32 whence, SceIoAsyncParam* asyncParam = SCE_NULL);
+		virtual SceInt32 LseekAsync(SceOff offset, SceInt32 whence, SceIoAsyncParam* asyncParam);
+		virtual SceInt32 Sync();
+		virtual SceInt32 SyncAsync();
+		virtual SceInt32 WaitAsync(io::AsyncResult *pResult);
+		virtual SceInt32 PollAsync(io::AsyncResult *pResult);
+		virtual SceInt32 GetStat(SceIoStat *stat); // not supported
+		virtual SceInt32 SetPriority(SceUInt32 ioPriority); // not supported
+
+		virtual ~MemFile();
+
+	private:
+
+		SceUChar8 m_work[0x4C];
+	};
+
+	class HttpFile
+	{
+	public:
+
+		HttpFile();
+
+		virtual SceInt32 GetType();
+		virtual SceInt32 unkFun_04();
+		virtual SceUInt64 GetSize();
+		virtual SceInt32 Open(Http *param);
+		virtual SceInt32 OpenAsync(Http *param);
+		virtual SceInt32 Close();
+		virtual SceInt32 CloseAsync();
+		virtual SceBool  IsOpened();
+		virtual SceBool  unkFun_20();
+		virtual SceInt32 CancelAsync();
+		virtual SceInt32 Read(ScePVoid buf, SceSize nbyte);
+		virtual SceInt32 ReadAsync(ScePVoid buf, SceSize nbyte);
+		virtual SceInt32 Write(const ScePVoid buf, SceSize nbyte); // not supported
+		virtual SceInt32 WriteAsync(const ScePVoid buf, SceSize nbyte); // not supported
+		virtual SceInt32 Lseek(SceOff offset, SceInt32 whence, SceIoAsyncParam* asyncParam = SCE_NULL);
+		virtual SceInt32 LseekAsync(SceOff offset, SceInt32 whence, SceIoAsyncParam* asyncParam);
+		virtual SceInt32 Sync();
+		virtual SceInt32 SyncAsync();
+		virtual SceInt32 WaitAsync(io::AsyncResult *pResult);
+		virtual SceInt32 PollAsync(io::AsyncResult *pResult);
+		virtual SceInt32 GetStat(SceIoStat *stat);
+		virtual SceInt32 SetPriority(SceUInt32 ioPriority);
+
+		virtual ~HttpFile();
+
+		static SceInt32 GetStat(const char *url, SceIoStat *stat);
+
+	private:
+
+		SceUChar8 m_work[0x4C];
+	};
+
 	class Module
 	{
 	public:
@@ -241,14 +465,16 @@ namespace paf {
 
 		Allocator(ScePVoid *membase, SceSize size, const char *name, Opt *pOpt = SCE_NULL);
 
+		virtual SceInt32 GetType();
+		virtual SceBool IsCdlgMemory();
+		virtual char* GetName();
+		virtual SceVoid GetInfo(ScePVoid **membase, SceSize *size);
+		virtual SceSize GetFreeSize();
+
 		virtual ~Allocator();
 
 		static Allocator *GetGlobalAllocator();
 
-		SceSize GetSize();
-
-		SceVoid GetMemBlockBase(ScePVoid *membase, ScePVoid *membaseTop);
-
 		SceVoid Deallocate(ScePVoid ptr);
 
 		ScePVoid Allocate(SceSize size);
@@ -271,7 +497,7 @@ namespace paf {
 
 		enum Type
 		{
-			Type_0,
+			Type_AutoDetect,
 			Type_PNG,
 			Type_JPEG,
 			Type_TIFF,
@@ -282,7 +508,7 @@ namespace paf {
 		};
 
 
-		class Result
+		class LoadResult
 		{
 		public:
 
@@ -290,15 +516,89 @@ namespace paf {
 			ScePVoid unk_04;
 		};
 
-		static SceVoid Load(Result *pRes, const char *pPath, ScePVoid buf, SceInt32 a4, SceInt32 a5, SceInt32 a6, SceInt32 a7);
+		class Resolution
+		{
+		public:
+
+			SceUInt32 width;
+			SceUInt32 height;
+		};
+
+		//ScePafMisc_57AD1093
+		static Type GetTypeFromFile(const char *pPath, SceInt32 unused, SceOff offset, SceIoAsyncParam* asyncIoParam);
+
+		//ScePafMisc_D77AEA5F
+		static Type GetTypeFromMem(ScePVoid imageBuf, SceSize imageSize);
+
+		static SceVoid LoadFromFile(LoadResult *pRes, const char *pPath, paf::Allocator *allocator, Type type, SceOff offset, SceIoAsyncParam* asyncIoParam, SceSize sizeWithoutOffset);
+
+		//ScePafMisc_C341D895
+		static SceInt32 LoadFromMem(LoadResult *pRes, ScePVoid imageBuf, SceSize imageSize, paf::Allocator *allocator, Type type);
+
+		//ScePafMisc_29E8BCA7
+		static SceVoid Convert(LoadResult *pRes, Image *pSrc, SceUInt32 targetType, SceInt32 a4);
+
+		//ScePafMisc_502BC2CF
+		static SceVoid ToTexture(paf::graphics::Texture *pTex, Image *pImg, SceInt32 a3);
 
 		static SceInt32 GetLastError();
 
 		static SceBool SetLastError(SceInt32 errorCode);
 
+		static SceVoid GetResolution(Resolution *pRes, Image *img);
+
 		SceInt32 GetType();
 
 		SceInt32 GetPaletteColorNum();
+
+		//147115CE
+		SceUInt32 GetFormat();
+
+		//7B15112F
+		SceUInt32 GetOrderType();
+	};
+
+	class Misc
+	{
+	public:
+
+		class OpenResult
+		{
+		public:
+
+			union
+			{
+				LocalFile *localFile;
+				MemFile *memFile;
+				HttpFile *httpFile;
+				io::Mem *memory;
+			};
+
+			ScePVoid unk_04;
+		};
+
+		static SceVoid OpenMemDirect(OpenResult *res, ScePVoid ptr, SceSize size);
+
+		static SceVoid OpenFile(OpenResult *res, const char *path, SceInt32 flag, SceIoMode mode, SceInt32 *error);
+
+		static SceVoid OpenMem(OpenResult *res, ScePVoid ptr, SceSize size, SceInt32 *error);
+
+		static SceVoid OpenMem(OpenResult *res, OpenResult *memory, SceInt32 *error);
+
+		static SceVoid OpenHttp(OpenResult *res, const SceWChar16 *url, SceInt32 *error, SceInt32 timeout);
+
+		static SceVoid OpenHttp(OpenResult *res, const char *url, SceInt32 *error, SceInt32 timeout);
+
+		static SceBool IsDolce();
+
+		static SceVoid SuspendTouchInput(SceUInt32 port);
+
+		static SceVoid ResumeTouchInput(SceUInt32 port);
+
+		//ScePafMisc_5E39FCE1
+		static SceInt32 Decompress(ScePVoid memOut, SceSize origsize, ScePVoid memIn, SceSize size, SceInt32 libType = 1);
+
+		static SceInt32 Test1(char *path);
 	};
 }
 
diff --git a/include/user/paf/stdc.h b/include/user/paf/stdc.h
index 1f72ced..74c2346 100644
--- a/include/user/paf/stdc.h
+++ b/include/user/paf/stdc.h
@@ -17,6 +17,8 @@ extern "C" {
  * std C functions
  */
 
+int sce_paf_abs(int x);
+int sce_paf_atoi(const char * str);
 void *sce_paf_bzero(void *ptr, SceSize num);
 void *sce_paf_memchr(const void *ptr, int value, SceSize num);
 int sce_paf_memcmp(const void *ptr1, const void *ptr2, SceSize num);
@@ -34,6 +36,12 @@ int sce_paf_strncasecmp(const char *str1, const char *str2, SceSize num);
 int sce_paf_strncmp(const char *str1, const char *str2, SceSize num);
 char *sce_paf_strncpy(char *destination, const char *source, SceSize num);
 char *sce_paf_strrchr(const char *str, int character);
+void sce_paf_qsort(void *ptr, SceSize count, SceSize size, int(*comp)(const void *, const void *));
+
+unsigned long int sce_paf_strtoul(const char* str, char** endptr, int base);
+
+int sce_paf_rand(void);
+void sce_paf_srand(unsigned int seed);
 
 /**
  * wchar functions
@@ -68,6 +76,13 @@ int sce_paf_wmemcmp(const wchar_t *lhs, const wchar_t *rhs, size_t count);
 wchar_t *sce_paf_wmemcpy(wchar_t *dest, const wchar_t *src, size_t count);
 wchar_t *sce_paf_wmemmove(wchar_t *dest, const wchar_t *src, size_t count);
 
+void *sce_paf_memalign(size_t align, size_t length);
+void sce_paf_free(void *ptr);
+void *sce_paf_malloc(size_t size);
+
+float sce_paf_ceilf(float arg);
+float sce_paf_floorf(float arg);
+
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/user/paf/thread.h b/include/user/paf/thread.h
index 2b4d683..deef546 100644
--- a/include/user/paf/thread.h
+++ b/include/user/paf/thread.h
@@ -234,8 +234,7 @@ namespace paf {
 
 		};
 
-		//Not usable yet
-		/*class JobQueue
+		class JobQueue
 		{
 		public:
 
@@ -293,11 +292,17 @@ namespace paf {
 
 			private:
 
-				SceUChar8 m_work[0x24];
+				SceUChar8 m_work[0x14];
 
 			};
 
-			typedef void(*QueueEntryFunction)(void *pArgBlock);
+			class ItemParam
+			{
+			public:
+
+				Item *item;
+				Request *request;
+			};
 
 			JobQueue(const char *pName, Opt *opt = SCE_NULL);
 
@@ -309,7 +314,7 @@ namespace paf {
 
 			static SceVoid DeleteDefaultJobQueue();
 
-			SceInt32 Push(Item *queueItem);
+			SceInt32 Push(ItemParam *queueItemParam);
 
 			SceVoid Join();
 
@@ -317,15 +322,15 @@ namespace paf {
 
 			SceVoid ChangeWorkerPriority(SceInt32 priority);
 
-			SceVoid Execute();
+			SceVoid Finish();
 
-			SceVoid Execute2();
+			SceVoid Execute();
 
 		private:
 
 			SceUChar8 m_work[0x2C];
 
-		};*/
+		};
 	}
 }
 
diff --git a/include/user/paf/toplevel.h b/include/user/paf/toplevel.h
index e5ec819..5d0c8f4 100644
--- a/include/user/paf/toplevel.h
+++ b/include/user/paf/toplevel.h
@@ -6,19 +6,12 @@
 #define _VDSUITE_USER_PAF_TOPLEVEL_H
 
 #include <kernel.h>
+#include <paf/graphics.h>
 #include <paf/resource.h>
+#include <paf/widget.h>
 
 namespace paf {
 
-	namespace graphics {
-		class Texture;
-		class MemoryPool;
-	}
-
-	namespace widget {
-		class Widget;
-	}
-
 	class Plugin
 	{
 	public:
@@ -29,17 +22,17 @@ namespace paf {
 
 		~Plugin() {};
 
-		class RootWidgetInitParam
+		class SceneInitParam
 		{
 		public:
 
-			RootWidgetInitParam();
+			SceneInitParam();
 
-			~RootWidgetInitParam() { };
+			~SceneInitParam() { };
 
 			SceInt32 unk_00;
 			SceInt32 unk_04;
-			SceInt32 unk_08;
+			SceInt32 priority;
 			SceUChar8 unk_0C[0x20];
 		};
 
@@ -59,20 +52,31 @@ namespace paf {
 
 		static SceVoid LoadTexture(paf::graphics::Texture *tex, Plugin *plugin, paf::Resource::Element *textureSearchParam);
 
-		paf::widget::Widget *SetRootWidget(paf::Resource::Element *widgetInfo, RootWidgetInitParam *initParam);
+		//6F7E804D
+		//SceInt32 AddTextureFromFile(paf::String *unk, const char *filePath, const char *a3);
+
+		paf::widget::Widget *CreateScene(paf::Resource::Element *widgetInfo, SceneInitParam *initParam);
+
+		paf::widget::Widget *CreateWidgetWithStyle(paf::widget::Widget *parent, const char *widgetType, paf::Resource::Element *widgetInfo, paf::Resource::Element *styleInfo);
+
+		paf::widget::Widget *GetSceneByHash(paf::Resource::Element *widgetInfo);
 
-		paf::widget::Widget *GetRootWidgetByHash(paf::Resource::Element *widgetInfo);
+		paf::widget::Widget *GetWidgetByNum(SceUInt32 num);
 
 		SceInt32 AddWidgetFromTemplate(paf::widget::Widget *targetRoot, paf::Resource::Element *templateSearchParam, paf::Plugin::TemplateInitParam *param);
 
-		SceUChar8 unk_00[0x4];
+		SceWChar16 *GetString(paf::Resource::Element *stringInfo);
+
+		SceUInt32 unk_00;
 		char *name;
 		SceUChar8 unk_08[0xA8];
 		Resource *resource;
+		SceUChar8 unk_B4[0x20];
+		graphics::MemoryPool *memoryPool;
 
 	private:
 
-		SceUChar8 m_unk_B4[0x4]; //size is unknown
+		SceUChar8 m_unk_B8[0x4]; //size is unknown
 
 	};
 
@@ -96,35 +100,57 @@ namespace paf {
 		{
 		public:
 
+			enum FeatureFlags
+			{
+				FeatureFlag_UseFwUpdateSync = 1,
+				FeatureFlag_DisableInternalCallbackChecks = 2,
+				FeatureFlag_4 = 4,
+				FeatureFlag_8 = 8
+			};
+
 			InitParam();
 
 			~InitParam() { };
 
 			InitParam *LoadDefaultParams();
 
-			SceUInt32 unk_00;
+			SceUInt32 gxmRingBufferSize;
 			SceUInt32 gxmParameterBufferSize;
 
-			SceUChar8 unk0[0x10];
+			SceUInt32 unk_08;
+			SceUInt32 defaultSurfacePoolSize;
+			SceUInt32 graphMemSystemHeapSize;
+
+			SceUInt32 graphMemVideoHeapSize;
 
 			SceUInt32 textSurfaceCacheSize;
+			SceUInt32 unk_1C;
+			SceUInt32 unk_20;
 
-			SceUChar8 unk1[0x40];
+			SceUChar8 unk_24[0x30];
 
+			SceUInt32 fontRasterizerFlags;
+			SceUInt32 fontRasterizerHeapSize;
 			SceUInt32 decodeHeapSize;
 			SceUInt32 defaultPluginHeapSize;
-			SceInt32 screenWidth; //unused
-			SceInt32 sceenHeight; //unused
+			SceUInt32 unkSize_64;
+			SceInt32 screenWidth;
+			SceInt32 sceenHeight;
 			ApplicationMode applicationMode;
-			SceInt32 optionalFeatureFlags;
+			SceUInt32 optionalFeatureFlags;
 			SceInt32 language;
 			SceInt32 enterButtonAssign;
-			SceBool useAdditionalWidgetInit;
+			SceUInt8 allowControlWithButtons;
+			SceUInt8 unkOptFlag1;
+			SceUInt8 unkOptFlag2;
+			SceUInt8 unkOptFlag3;
 			ScePVoid unk_84;
 			SceInt32 unused_88;
 			SceInt32 graphicsFlags;
 
-			SceUChar8 unk2[0x134];
+			SceUInt32 unk_140;
+
+			SceUChar8 unk2[0x20];
 		};
 
 		class CommonResourceInitParam
@@ -156,7 +182,11 @@ namespace paf {
 			paf::Plugin::PluginCB unloadCB2;
 			paf::String resourcePath;
 
-			SceUChar8 unk_38[0x20];
+			SceUChar8 unk_38[0xC];
+
+			SceUInt32 pluginHeapSize;
+
+			SceUChar8 unk_48[0x10];
 
 			SceInt32 unk_58;
 
@@ -187,7 +217,9 @@ namespace paf {
 
 		static paf::graphics::MemoryPool *GetDefaultGraphicsMemoryPool();
 
-		static SceVoid LoadTexture(paf::graphics::Texture *tex, Framework *fw, paf::Resource::Element *searchParam);
+		static SceVoid LoadTextureCurrentPlugin(paf::graphics::Texture *tex, Framework *fw, paf::Resource::Element *searchParam);
+
+		static SceVoid CreateTextureFromMemory(paf::graphics::Texture *tex, Plugin *plugin, ScePVoid ptr, SceSize size, paf::Image::Type type, SceBool isCompressed, SceSize origsize);
 
 		SceVoid _LoadPluginAsync(PluginInitParam *initParam, LoadPluginFinishCallback finishCallback = SCE_NULL, UnloadPluginFinishCallback unloadFinishCallback = SCE_NULL);
 
@@ -207,15 +239,29 @@ namespace paf {
 
 		ApplicationMode GetApplicationMode();
 
-		SceInt32 Test2(SceFloat32, SceInt32, SceInt32);
+		paf::widget::Widget *GetCurrentScene();
+
+		SceWChar16 *GetCRString(paf::Resource::Element *stringInfo);
 
-		paf::widget::Widget *GetRootWidget();
+		SceUChar8 unk_00[0x18];
 
-		SceUChar8 unk_00[0x1C];
+		SceUInt32 loadedPluginNum;
 
 		Plugin *crPlugin;
 
-		SceUChar8 unk_20[0x5C];
+		SceUChar8 unk_20[0x34];
+
+		ApplicationMode applicationMode;
+
+		SceUInt32 optionalFeatureFlags;
+
+		SceUInt32 language;
+
+		SceUChar8 unk_60[0x14];
+
+		SceUID powerCallbackId;
+
+		paf::Allocator *defaultAllocator;
 	};
 }
 
diff --git a/include/user/paf/widget.h b/include/user/paf/widget.h
index c7c25e9..b22cc00 100644
--- a/include/user/paf/widget.h
+++ b/include/user/paf/widget.h
@@ -14,6 +14,8 @@ namespace paf {
 	class WString;
 
 	namespace graphics {
+		class DrawQueue;
+		class TextObj;
 		class Texture;
 	}
 
@@ -142,8 +144,8 @@ namespace paf {
 			virtual int unkFun_084();
 			virtual int unkFun_088();
 			virtual int unkFun_08C();
-			virtual int unkFun_090_anim(SceInt32 animationCode, SceBool setSomeFloat);
-			virtual int unkFun_094_animRev(SceInt32 animationCode, SceBool setSomeFloat);
+			virtual int unkFun_090_anim(SceFloat32 a1, SceInt32 animationCode, SceBool setSomeFloat);
+			virtual int unkFun_094_animRev(SceFloat32 a1, SceInt32 animationCode, SceBool setSomeFloat);
 			virtual int unkFun_098();
 			virtual int unkFun_09C();
 			virtual int unkFun_0A0();
@@ -168,9 +170,9 @@ namespace paf {
 			virtual int unkFun_0EC();
 			virtual int unkFun_0F0();
 			virtual int unkFun_0F4();
-			virtual int unkFun_0F8(SceInt32);
-			virtual int unkFun_0FC();
-			virtual int SetTexture(paf::graphics::Texture *tex);
+			virtual graphics::DrawQueue *GetDrawQueue(SceInt32 a1 = 0);
+			virtual int SetTexture(paf::graphics::Texture *tex, SceInt32 childNum, SceInt32 a3 = 0);
+			virtual int SetTextureBase(paf::graphics::Texture *tex);
 			virtual int unkFun_104();
 			virtual int unkFun_108();
 			virtual int unkFun_10C();
@@ -178,11 +180,11 @@ namespace paf {
 			virtual int unkFun_114();
 			virtual SceInt32 SetLabelWithFlag(paf::WString *text, SceInt32 flag);
 			virtual SceInt32 SetLabel(paf::WString *text);
-			virtual int unkFun_120();
-			virtual int unkFun_124();
+			virtual SceInt32 GetLabelWithFlag(paf::WString *text, SceInt32 flag);
+			virtual SceInt32 GetLabel(paf::WString *text);
 			virtual int unkFun_128();
 			virtual int unkFun_12C();
-			virtual int unkFun_130();
+			virtual int unkFun_130(SceInt32);
 			virtual int unkFun_134(SceInt32);
 			virtual int unkFun_138();
 			virtual int unkFun_13C();
@@ -207,7 +209,7 @@ namespace paf {
 			virtual int unkFun_188();
 			virtual int unkFun_18C();
 			virtual int unkFun_190();
-			virtual int unkFun_194();
+			virtual int unkFun_194(SceFloat32 a1, SceFVector4 *a2, SceInt32 a3, SceInt32 a4, SceInt32 a5);
 			virtual int unkFun_198();
 			virtual int unkFun_19C();
 			virtual int unkFun_1A0();
@@ -256,6 +258,8 @@ namespace paf {
 
 			static char *TypeScrollViewParent();
 
+			static char *TypeScrollView();
+
 			static char *TypeScrollBar2D();
 
 			static char *TypeScrollBarTouch();
@@ -326,17 +330,37 @@ namespace paf {
 
 			SceInt32 SetAdjust(SceBool x, SceBool y, SceBool z);
 
+			SceVoid SetGraphicsDisabled(SceBool disable);
+
+			enum EventCtrl
+			{
+				EventCtrl_ButtonPress = 0x10001,
+				EventCtrl_ButtonRelease = 0x10002,
+				EventCtrl_ButtonHold = 0x10003
+			};
+
+			enum EventFocus
+			{
+				EventFocus_On = 0x40001,
+				EventFocus_Off = 0x40002
+			};
+
+			enum EventMain
+			{
+				EventMain_Pressed = 0x10000008
+			};
+
 			SceInt32 RegisterEventCallback(SceInt32 eventId, EventCallback *cb, SceBool a3);
 
 			SceInt32 UnregisterEventCallback(SceInt32 eventId, SceInt32 a2, SceInt32 a3);
 
-			SceInt32 RegisterLoopEventCallback(SceInt32 eventId, EventCallback *cb);
+			SceInt32 RegisterFwEventCallback(SceFloat32 delay, SceInt32 eventId, EventCallback *cb);
 
-			SceInt32 UnregisterLoopEventCallback(SceInt32 eventId);
+			SceInt32 UnregisterFwEventCallback(SceInt32 eventId);
 
 			SceInt32 AssignButton(SceUInt32 buttons);
 
-			SceInt32 SetDimFactor(SceFloat32 factor, SceInt32 a2 = 0, SceInt32 a3 = 0x10003, SceInt32 a4 = 0, SceInt32 a5 = 0, SceInt32 a6 = 0);
+			SceInt32 SetAlpha(SceFloat32 alpha, SceInt32 a2 = 0, SceInt32 a3 = 0x10003, SceInt32 a4 = 0, SceInt32 a5 = 0, SceInt32 a6 = 0);
 
 			SceVoid Disable(SceBool a1);
 
@@ -390,11 +414,19 @@ namespace paf {
 
 			};
 
-			SceInt32 PlayAnimation(Animation animId, EventCallback::EventHandler animCB = 0, ScePVoid pUserData = SCE_NULL);
+			SceInt32 PlayAnimation(SceFloat32 animationSpeed, Animation animId, EventCallback::EventHandler animCB = 0, ScePVoid pUserData = SCE_NULL);
+
+			SceInt32 PlayAnimationReverse(SceFloat32 animationSpeed, Animation animId, EventCallback::EventHandler animCB = 0, ScePVoid pUserData = SCE_NULL);
 
-			SceInt32 PlayAnimationReverse(Animation animId, EventCallback::EventHandler animCB = 0, ScePVoid pUserData = SCE_NULL);
+			SceUChar8 unk_004[0x5D];
 
-			SceUChar8 unk_004[0x148];
+			SceUInt8 unk_061;
+
+			SceUChar8 unk_062[0x74];
+
+			SceUInt8 unk_0D6;
+
+			SceUChar8 unk_0D7[0x75];
 
 			SceUInt32 hash;
 
@@ -406,16 +438,24 @@ namespace paf {
 
 			SceUInt8 animationStatus;
 
-			SceUChar8 unk_197[0xF5];
+			SceUChar8 unk_197[0xE9];
+
+			graphics::TextObj *textObj;
+
+			SceUChar8 unk_284[0x8];
 
 			Color *pDisabledColor;
 
-			SceUChar8 unk_290[0x5];
+			SceUInt32 unk_290;
+
+			SceUChar8 unk_294[0x1];
 
 		private:
 
 		};
 
+		static int a = sizeof(Widget);
+
 		class BusyIndicator : public Widget
 		{
 		public:
@@ -443,9 +483,11 @@ namespace paf {
 
 			virtual ~Text();
 
+			SceUInt32 unk_298;
+
 		private:
 
-			SceUChar8 unk_298[0x40];
+			SceUChar8 unk_29C[0x3C];
 		};
 
 		class TextBox : public Widget
@@ -575,6 +617,67 @@ namespace paf {
 			virtual ~ScrollViewParent();
 		};
 
+		class ScrollView : public Widget
+		{
+		public:
+
+			ScrollView(Widget *parent, SceInt32 a2);
+
+			virtual ~ScrollView();
+
+			virtual int unkFun_1AC();
+			virtual int unkFun_1B0();
+			virtual int unkFun_1B4();
+			virtual int unkFun_1B8();
+			virtual int unkFun_1BC();
+			virtual int unkFun_1C0();
+			virtual int unkFun_1C4();
+			virtual int unkFun_1C8();
+			virtual int unkFun_1CC();
+			virtual int unkFun_1D0();
+			virtual int unkFun_1D4();
+			virtual int unkFun_1D8();
+			virtual int unkFun_1DC();
+			virtual int unkFun_1E0();
+			virtual int unkFun_1E4();
+			virtual int unkFun_1E8();
+			virtual int unkFun_1EC();
+			virtual int unkFun_1F0();
+			virtual int unkFun_1F4();
+			virtual int unkFun_1F8();
+			virtual int unkFun_1FC();
+			virtual int unkFun_200();
+			virtual int unkFun_204();
+			virtual int unkFun_208();
+			virtual int unkFun_20C();
+			virtual int unkFun_210();
+			virtual int unkFun_214();
+			virtual int unkFun_218();
+			virtual int unkFun_21C();
+			virtual int unkFun_220();
+			virtual int unkFun_224();
+			virtual int unkFun_228();
+			virtual int unkFun_22C(SceInt32 a2);
+			virtual int unkFun_230();
+			virtual int unkFun_234();
+			virtual int unkFun_238();
+			virtual int unkFun_23C();
+			virtual int unkFun_240(SceFVector4 *a1, SceInt32 a2);
+			virtual int unkFun_244();
+			virtual int unkFun_248(SceInt32 a1);
+			virtual int unkFun_24C(SceInt32 a1);
+			virtual int unkFun_250();
+			virtual int unkFun_254(SceUInt64 *a1, SceInt32 a2, SceInt32 a3, SceInt32 a4);
+			virtual int unkFun_258(SceInt32 a1);
+			virtual int unkFun_25C();
+			virtual int unkFun_260(SceFVector4 *a1, SceInt32 a2);
+			virtual int unkFun_264();
+			virtual int unkFun_268();
+			virtual int unkFun_26C();
+			virtual int unkFun_270();
+			virtual int unkFun_274(SceInt32 a1);
+		};
+
 		class ScrollBar2D : public Widget
 		{
 		public:
@@ -636,6 +739,36 @@ namespace paf {
 			ProgressBar(Widget *parent, SceInt32 a2);
 
 			virtual ~ProgressBar();
+
+			virtual int unkFun_1AC();
+			virtual int unkFun_1B0();
+			virtual int unkFun_1B4();
+			virtual int unkFun_1B8();
+			virtual int unkFun_1BC();
+			virtual int unkFun_1C0();
+			virtual int unkFun_1C4();
+			virtual int unkFun_1C8();
+			virtual int unkFun_1CC();
+			virtual int unkFun_1D0();
+			virtual int unkFun_1D4();
+			virtual int unkFun_1D8();
+			virtual int unkFun_1DC();
+			virtual int unkFun_1E0();
+			virtual int unkFun_1E4();
+			virtual int SetProgress(SceFloat32 value, SceUInt32 a2, SceUInt32 a3);
+			virtual int unkFun_1EC();
+			virtual int unkFun_1F0();
+			virtual int unkFun_1F4();
+			virtual int unkFun_1F8();
+			virtual int unkFun_1FC();
+			virtual int unkFun_200();
+
+			SceUChar8 unk_295[0x7];
+
+			SceFloat32 fullValue;
+			SceFloat32 unk_2A0;
+			SceFloat32 currentValue;
+
 		};
 
 		class ProgressBarTouch : public Widget
@@ -645,6 +778,35 @@ namespace paf {
 			ProgressBarTouch(Widget *parent, SceInt32 a2);
 
 			virtual ~ProgressBarTouch();
+
+			virtual int unkFun_1AC();
+			virtual int unkFun_1B0();
+			virtual int unkFun_1B4();
+			virtual int unkFun_1B8();
+			virtual int unkFun_1BC();
+			virtual int unkFun_1C0();
+			virtual int unkFun_1C4();
+			virtual int unkFun_1C8();
+			virtual int unkFun_1CC(SceInt32 a1);
+			virtual int unkFun_1D0();
+			virtual int unkFun_1D4();
+			virtual int unkFun_1D8();
+			virtual int unkFun_1DC();
+			virtual int unkFun_1E0();
+			virtual int unkFun_1E4();
+			virtual int SetProgress(SceFloat32 value, SceUInt32 a2, SceUInt32 a3);
+			virtual int unkFun_1EC();
+			virtual int unkFun_1F0();
+			virtual int unkFun_1F4();
+			virtual int unkFun_1F8();
+			virtual int unkFun_1FC();
+			virtual int unkFun_200();
+
+			SceUChar8 unk_295[0x7];
+
+			SceFloat32 fullValue;
+			SceFloat32 unk_2A0;
+			SceFloat32 currentValue;
 		};
 
 		class ListItem : public Widget //0x2d0