KFar-API

The plugin is a standard kolibri library (COFF format). The plugin must export the following functions and variables (some features may not be available). Functions may destroy any registers. KFAR also guarantees DF flag is cleared when a function is called, and expects the same for the callback functions.

plugin structure

<syntaxhighlight lang="c"> int version; </syntaxhighlight> KFAR interface version, current version is 2. <syntaxhighlight lang="c"> typedef struct {

        int StructSize; // = sizeof(kfar_info)
        int kfar_ver;   // 10000h*major + minor
/* The callback function preserves all registers except eax. */
/* File functions: */
        void* open;     // HANDLE __stdcall open(const char* name, int mode);
                        // mode - a combination of bit flags
                        // O_READ = 1 - read access
                        // O_WRITE = 2 - write access
                        // O_CREATE = 4 - if the file does not exist, create it
                        // O_TRUNCATE = 8 - truncate the file to zero len
        void* open2;    // HANDLE __stdcall open2(int plugin_id, HANDLE plugin_instance,
                        //                      const char* name, int mode);
                        // similar to open, but it opens the file with the plugin panel
                        // open2(0,<anything>,name,mode) = open(name,mode)
        void* read;     // unsigned __stdcall read(HANDLE hFile, void* buf, unsigned size);
        void* write;    // not yet implemented
        void* seek;     // void __stdcall seek(HANDLE hFile, int method, __int64 newpos);
        void* tell;     // __int64 __stdcall tell(HANDLE hFile);
        void* flush;    // not yet implemented
        void* filesize; // __int64 __stdcall filesize(HANDLE hFile);
        void* close;    // void __stdcall close(HANDLE hFile);
/* Functions to work with the memory (page) */
        void* pgalloc;  // in: ecx=size, out: eax=pointer or NULL
                        // Out of memory, informs the user and returns NULL
        void* pgrealloc; // in: edx=pointer, ecx=new size, out: eax=pointer or NULL
                        // Out of memory, informs the user and returns NULL
        void* pgfree;   // in: ecx=pointer
        void* getfreemem;       // unsigned __stdcall getfreemem(void);
                                // returns the size of free memory in KB
        void* pgalloc2;         // void* __stdcall pgalloc2(unsigned size);
        void* pgrealloc2;       // void* __stdcall pgrealloc2(void* pointer, unsigned size);
        void* pgfree2;          // void __stdcall pgfree2(void* pointer);
/* Functions for the dialogue: */
        void* menu;     // int __stdcall menu(void* variants, const char* title, unsigned flags);
                        // variants points to the current element in the linked list
        void* menu_centered_in; // int __stdcall menu_centered_in(unsigned left, unsigned top,
                                // unsigned width, unsigned height,
                                // void* variants, const char* title, unsigned flags);
        void* DialogBox;        // int __stdcall DialogBox(DLGDATA* dlg);
        void* SayErr;           // int __stdcall SayErr(int num_strings, const char** strings,
                                //                      int num_buttons, const char** buttons);
        void* Message;          // int __stdcall Message(const char* title,
                                //                      int num_strings, const char** strings,
                                //                      int num_buttons, const char** buttons);
                                // may be x=-1 and/or y=-1
        struct {unsigned width;unsigned height;}* cur_console_size;

} kfar_info; </syntaxhighlight>

plugin_load()

<syntaxhighlight lang="c"> int __stdcall plugin_load(kfar_info* info); </syntaxhighlight> Called when the plugin is loaded.

return

0	successful initialization
1	Initialization error (KFAR will display a message to the user)
2	Initialization error (KFAR will continue without informing the user)

plugin_unload()

<syntaxhighlight lang="c"> void __stdcall plugin_unload(void); </syntaxhighlight> Called to unload the plugin (when KFAR is being shut down).

OpenFilePlugin()

<syntaxhighlight lang="c"> HANDLE __stdcall OpenFilePlugin(HANDLE basefile,

        const void* attr, const void* data, int datasize,
        int baseplugin_id, HANDLE baseplugin_instance, const char* name);

</syntaxhighlight> Opens plugin that emulates a filesystem on the basis of a file (for example, archive)