#ifndef N_MACROS
#define N_MACROS

////////////////////////////////////////////////////////////////////////////////
// n_macros.h
// Various macros collected in one file by nkls
//  Needed by most of my sources
//  Use it and share it any way you want.
////////////////////////////////////////////////////////////////////////////////



////////////////////////////////////////////////////////////////////////////////
// STRID / IMGID

#define STRID_NULL  0x6FFFFFFF    // I've got used to these, but they are the 
#define IMGID_NULL  0xFFFF        // same as NOIMAGE and EMPTY_SID

#define IMGID wchar_t


////////////////////////////////////////////////////////////////////////////////
// MAX / MIN / ABS

#ifndef MIN
#define MIN(_a_, _b_) (((_a_)<(_b_))?(_a_):(_b_))
#endif

#ifndef MAX
#define MAX(_a_, _b_) (((_a_)>(_b_))?(_a_):(_b_))
#endif

#ifndef ABS
#define ABS(_a_) ((_a_)>=0?(_a_):-(_a_))
#endif


////////////////////////////////////////////////////////////////////////////////
// STRID macros

// 16-bit wchar_t strings
#define WSTR2ID(_wstr_)           Str2ID(_wstr_, 0, SID_ANY_LEN)
#define CWSTR2ID(_wstr_)          Str2ID(_wstr_, 0, MAXELEMS(_wstr_)-1)
#define WSTRN2ID(_wstr_, _LEN_)   Str2ID(_wstr_, 0, _LEN_)

// 8-bit char strings
#define STR2ID(_str_)             Str2ID(_str_, 6, SID_ANY_LEN)
#define CSTR2ID(_str_)            Str2ID(_str_, 6, sizeof(_str_)-1)
#define STRN2ID(_str_, _LEN_)     Str2ID(_str_, 6, _LEN_)

// STRID merge
#define MERGEID(_IDArray_, _LEN_) Str2ID(_IDArray_, 5, _LEN_)

// Integer to STRID
#define INT2ID                    int2strID

// String element to ID
#define STRELEM2ID(_elem_)        (0x78000000+(_elem_))


// PRNTFSTRID
#define PRNTFSTRID(_buf_, ...)    STRN2ID(_buf_, sprintf(_buf_, __VA_ARGS__))



////////////////////////////////////////////////////////////////////////////////
// MessageBox() macros

// STRID Message box (with timeout and parent book) macro
#define STRIDMSGTB(__STRID__, __TIME__, __BOOK__) MessageBox(STRID_NULL, __STRID__, IMGID_NULL, 1, __TIME__, __BOOK__)

// String Message box (with timeout and parent book) macros
#define WSTRMSGTB(__LSTR__, __TIME__, __BOOK__)   STRIDMSGTB(WSTR2ID(__LSTR__), __TIME__, __BOOK__)
#define STRMSGTB(__STR__, __TIME__, __BOOK__)     STRIDMSGTB(STR2ID(__STR__), __TIME__, __BOOK__)
#define CWSTRMSGTB(__LSTR__, __TIME__, __BOOK__)  STRIDMSGTB(CWSTR2ID(__LSTR__), __TIME__, __BOOK__)
#define CSTRMSGTB(__STR__, __TIME__, __BOOK__)    STRIDMSGTB(CSTR2ID(__STR__), __TIME__, __BOOK__)



// STRID Message box (with parent book and no timeout) macro
#define STRIDMSGB(__STRID__, __BOOK__)            STRIDMSGTB(__STRID__, 0, __BOOK__)

// String Message box (with parent book and no timeout) macros
#define WSTRMSGB(__LSTR__, __BOOK__)              STRIDMSGB(WSTR2ID(__LSTR__), __BOOK__)
#define STRMSGB(__STR__, __BOOK__)                STRIDMSGB(STR2ID(__STR__), __BOOK__)
#define CWSTRMSGB(__LSTR__, __BOOK__)             STRIDMSGB(CWSTR2ID(__LSTR__), __BOOK__)
#define CSTRMSGB(__STR__, __BOOK__)               STRIDMSGB(CSTR2ID(__STR__), __BOOK__)



// STRID Message box (with no parent book and timeout) macro
#define STRIDMSGT(__STRID__, __TIME__)            STRIDMSGBT(__STRID__, __TIME__, NULL)

// String Message box (with no parent book and timeout) macros
#define WSTRMSGT(__LSTR__, __TIME__)              STRIDMSGT(WSTR2ID(__LSTR__), __TIME__)
#define STRMSGT(__STR__, __TIME__)                STRIDMSGT(STR2ID(__STR__), __TIME__)
#define CWSTRMSGT(__LSTR__, __TIME__)             STRIDMSGT(CWSTR2ID(__LSTR__), __TIME__)
#define CSTRMSGT(__STR__, __TIME__)               STRIDMSGT(CSTR2ID(__STR__), __TIME__)



// STRID Message box macro
#define STRIDMSG(__STRID__)                       STRIDMSGB(__STRID__, NULL)

// String Message box macros
#define WSTRMSG(__LSTR__)                         STRIDMSG(WSTR2ID(__LSTR__))
#define STRMSG(__STR__)                           STRIDMSG(STR2ID(__STR__))
#define CWSTRMSG(__LSTR__)                        STRIDMSG(CWSTR2ID(__LSTR__))
#define CSTRMSG(__STR__)                          STRIDMSG(CSTR2ID(__STR__))

// PRINTFMSG
#define PRINTFMSG(_buf_, ...)                     STRIDMSG(STRN2ID(_buf_, sprintf(_buf_, __VA_ARGS__)))


////////////////////////////////////////////////////////////////////////////////
// DEBUG

// DEBUG Condition Message
#ifndef NDEBUG
#define DEBCOND(cond)        {if(cond){debug_printf("\nDEBCOND: %s\n", #cond);CSTRMSG(#cond);}}
#define DEBCONDS(cond,_str_) {if(cond){debug_printf("\nDEBCOND: %s\n", _str_);CSTRMSG(_str_);}}
#else
#define DEBCOND(...)
#define DEBCONDS(...)
#endif

////////////////////////////////////////////////////////////////////////////////
// Debug msg and printf. note: no printf message longer than 300 chars!

#ifndef NDEBUG
#define DEBUG_MSG(_str_) STRMSG(_str_)
#define DEBUG_PRINTF(...) debug_printf(__VA_ARGS__)
#define DEBUG_PRINTF_MSG(...) {char s[300];STRN2ID(s, MAX(sprintf(s, __VA_ARGS__), 299));}
#else
#define DEBUG_MSG(_str_)
#define DEBUG_PRINTF(...)
#define DEBUG_PRINTF_MSG(...)
#endif

#endif

////////////////////////////////////////////////////////////////////////////////
//
// Opera Mini Accelerometer Control (OMAC)  -  main.c
//   (c) nkls 2010-2011
//
// 
// 
//
////////////////////////////////////////////////////////////////////////////////


////////////////////////////////////////////////////////////////////////////////
// Includes
#include <Lib_Clara.h>
#include <Dll.h>
//#include <n_macros.h>       ------------------------------------------------------------------------------

#include "accelerometer_interface.h"

#include "..\Dlls\Accelerometer\export\AccelerometerDll.h"


////////////////////////////////////////////////////////////////////////////////
// Definitions
#define ELF_NAME             "OperaMini AccelControl"
#define ELF_VERSION          "v1.1" "Я"
#define ELF_AUTHOR           "nkls"

#define STR_ABOUT            ELF_NAME " " ELF_VERSION "\n" \
                             "© " ELF_AUTHOR          "\n" \
                                                      "\n" \
                             "build " __DATE__ " " __TIME__


////////////////////////////////////////////////////////////////////////////////
// Typedefs

typedef struct {
  BOOK * book;
  DISP_OBJ_ONCLOSE_METHOD defOnClose;
  DISP_OBJ_ONKEY_METHOD defOnKey;
}OM_HOOK_DATA;

typedef enum {
  SCROLL_NO_SCROLL=0,
  SCROLL_UP,
  SCROLL_DOWN,
  SCROLL_LEFT,
  SCROLL_RIGHT,
} SCROLL_MODE;

typedef struct {
  BOOK book;
  OM_HOOK_DATA * hook;
  ACCELEROMETER_DLL_DATA * acc_dll;
  u16 catch_timer;
  u16 acc_check_timer;
  u16 check_timer_retries;
  SCROLL_MODE scroll;

  int tilt;
  int catch_retry_count;
  bool isHorizontal;
  bool isTiltScrollActivated;
  bool usingz;
}OMAC_BOOK;


////////////////////////////////////////////////////////////////////////////////
// Method declarations
static void onCloseBook(BOOK * book);
void freeOMBookHook(OM_HOOK_DATA * omdata);
void onAccCheckTimer(u16, LPARAM data);
int onMainGotFocus(void * msg, BOOK * book, PAGE_DESC * page_desc, LPARAM _omacbook, u16);
int onMainLostFocus(void * msg, BOOK * book, PAGE_DESC * page_desc, LPARAM _omacbook, u16);


////////////////////////////////////////////////////////////////////////////////
// elf exit
void elf_exit(void){kill_data(&ELF_BEGIN, (void(*)(void*))mfree_adr());}


////////////////////////////////////////////////////////////////////////////////
// book methods
int isCUIDisplayableBook(BOOK * bk) {
  if(!strcmp(bk->xbook->name, "CUIDisplayableBook"))
    return 1;
  return 0;
}

int isOMBook(BOOK * bk) {
  if(!strcmp(bk->xbook->name, "CUIDisplayableBook")) {
    char s[32];
    TextID_GetString(BookObj_GetSession(bk)->name, s, MAXELEMS(s));
    if(!strcmp(s, "Opera Mini"))
      return 1;
  }
  return 0;
}

int isOurOMACBook(BOOK * bk) {
  if(bk->onClose == onCloseBook)
    return 1;
  return 0;
}

int isAnyOMACBook(BOOK * bk) {
  if(!strcmp(bk->xbook->name, ELF_NAME))
    return 1;
  return 0;
}

int isBook(BOOK * b, int * p) {
  return ((int*)b == p) ? 1 : 0;
}


bool BookExist(BOOK * book) {
  return (FindBookEx(isBook, (int*)book) != NULL);
}

inline GUI * BOOK_GetTopGUI(BOOK * b) {
  return (GUI*)List_Get(b->xguilist->guilist, 0);
}

////////////////////////////////////////////////////////////////////////////////
// Hook related methods and hooks
void myOMOnKey(DISP_OBJ * p, int key, int i2, int i3, int mode) {
  //DEBUG_PRINTF("\nmyOMOnKey(%X, %d, %d, %d, %d)\n", p, key, i2, i3, mode);     ------------------------------------------------------
  OMAC_BOOK * bk = (OMAC_BOOK*)FindBook(isOurOMACBook);
  if(bk) {
    if(key == KEY_DIGITAL_0 && mode == KBD_SHORT_PRESS) {
      if(bk->isTiltScrollActivated ^= 1) {
        int x, y, z;
        if(ACCELEROMETER_GetCoords(bk->acc_dll, &x, &y, &z, 1) >= 0) {
          int useaxis = (bk->isHorizontal)?x:y;
          if(z < useaxis) {
            bk->usingz = 1;
            bk->tilt = z;
          } else {
            bk->usingz = 0;
            bk->tilt = useaxis;
          }
        }
        else bk->isTiltScrollActivated = 0;
      } else {
        int send_key = -1;
        if(bk->scroll == SCROLL_DOWN)send_key = KEY_DOWN;
        else if(bk->scroll == SCROLL_UP)send_key = KEY_UP;
        else if(bk->scroll == SCROLL_LEFT)send_key = KEY_LEFT;
        else if(bk->scroll == SCROLL_RIGHT)send_key = KEY_RIGHT;
        if(send_key != -1)
        {

         bk->hook->defOnKey(p, send_key, i2, i3, KBD_LONG_RELEASE);
        }
      }
    }
    else

      bk->hook->defOnKey(p, key, i2, i3, mode);
  }
}

void myOMOnClose(DISP_OBJ * p) {
  //DEBUG_PRINTF("\nmyOMOnClose(%X)\n", p);   ------------------------------------------------------
  OMAC_BOOK * bk = (OMAC_BOOK*)FindBook(isOurOMACBook);
  if(bk) {
    bk->hook->defOnClose(p);
    //DEBUG_PRINTF("\nmyOMOnClose: releasing hook structure...\n");                        ------------------------------------------------------
    freeOMBookHook(bk->hook);
    bk->hook = NULL;
    if(ACCELEROMETER_IsOpen(bk->acc_dll))
      ACCELEROMETER_Close(bk->acc_dll);

    ModifyUIPageHook(MAIN_WINDOW_GOT_FOCUS_EVENT, onMainGotFocus, 0, PAGE_HOOK_REMOVE);
    ModifyUIPageHook(MAIN_WINDOW_LOST_FOCUS_EVENT, onMainLostFocus, 0, PAGE_HOOK_REMOVE);

    bk->isTiltScrollActivated = 0;
    if(bk->acc_check_timer)
      Timer_Kill(&bk->acc_check_timer);
  }
  //else CSTRMSG("Critical error! :,(");                         ------------------------------------------------------

 // DEBUG_PRINTF("\nmyOMOnClose: DONE!\n");                        ------------------------------------------------------
}


OM_HOOK_DATA * getOMBookHook(BOOK * ombook) {
  OM_HOOK_DATA * omdata = (OM_HOOK_DATA*)malloc(sizeof(OM_HOOK_DATA));
  memset(omdata, 0, sizeof(OM_HOOK_DATA));

  //DEBUG_PRINTF("\ngetOMBookHook: creating hook structure (%X)\n", omdata);                        ------------------------------------------------------
  
  omdata->book = ombook;

  GUI * gui = BOOK_GetTopGUI(ombook);
  if(gui) {
    DISP_OBJ * disp_obj = GUIObject_GetDispObject(gui);
    DISP_DESC * disp_desc = DispObject_GetDESC(disp_obj);

    omdata->defOnClose = DispObject_GetOnClose(disp_obj);
    if(omdata->defOnClose && omdata->defOnClose != myOMOnClose)
      DISP_DESC_SetOnClose(disp_desc, myOMOnClose);
    
    omdata->defOnKey = DispObject_GetOnKey(disp_obj);
    if(omdata->defOnKey && omdata->defOnKey != myOMOnKey)
      DISP_DESC_SetOnKey(disp_desc, myOMOnKey);
    
//    DEBUG_PRINTF("\ngetOMBookHook: filled in data structures OK\n", omdata);                        ------------------------------------------------------
    return omdata;
  }
  //DEBUG_PRINTF("\ngetOMBookHook: failed!\n", omdata);                        ------------------------------------------------------
  mfree(omdata);
  return NULL;
}


void freeOMBookHook(OM_HOOK_DATA * omdata) {
  //DEBUG_PRINTF("\nfreeOMBookHook: starting to reset hooks...\n", omdata);                        ------------------------------------------------------
  if(BookExist(omdata->book)) {
    GUI * gui = BOOK_GetTopGUI(omdata->book);
    if(gui) {
      DISP_OBJ * disp_obj = GUIObject_GetDispObject(gui);
      DISP_DESC * disp_desc = DispObject_GetDESC(disp_obj);
      DISP_OBJ_ONCLOSE_METHOD doc = DispObject_GetOnClose(disp_obj);
      if(doc == myOMOnClose)
        DISP_DESC_SetOnClose(disp_desc, omdata->defOnClose);
      
      DISP_OBJ_ONKEY_METHOD dok = DispObject_GetOnKey(disp_obj);
      if(dok == myOMOnKey)
        DISP_DESC_SetOnKey(disp_desc, omdata->defOnKey);

      ModifyUIPageHook(MAIN_WINDOW_GOT_FOCUS_EVENT, onMainGotFocus, 0, PAGE_HOOK_REMOVE);
      ModifyUIPageHook(MAIN_WINDOW_LOST_FOCUS_EVENT, onMainLostFocus, 0, PAGE_HOOK_REMOVE);
    }
  }
  //DEBUG_PRINTF("\nfreeOMBookHook: done, releasing hook structure...\n", omdata);                        ------------------------------------------------------
  mfree(omdata);
}


////////////////////////////////////////////////////////////////////////////////
// catch timer
void onCatchTimer(u16, LPARAM _omacbook) {
  BOOK * b;
  OMAC_BOOK * omacbook = (OMAC_BOOK*)_omacbook;
  if(omacbook) {
    if(b = FindBook(isOMBook)) {
      //DEBUG_PRINTF("\nonCatchTimer: found Opera Mini book! (%X)\n", b);                        ------------------------------------------------------
      omacbook->hook = getOMBookHook(b);
      if(omacbook->hook == NULL) {
//        DEBUG_PRINTF("\nonCatchTimer: could not hook, retrying in one second...\n", b);                        ------------------------------------------------------
        omacbook->catch_retry_count = 1;
        Timer_ReSet(&omacbook->catch_timer, 1000, onCatchTimer, omacbook);
      }
      else {
        //DEBUG_PRINTF("\nonCatchTimer: hooked ok, opening accelerometer handle...\n", b);                        ------------------------------------------------------
        omacbook->catch_retry_count = 0;
        omacbook->catch_timer = 0;
        if(!ACCELEROMETER_IsOpen(omacbook->acc_dll))
          ACCELEROMETER_Open(omacbook->acc_dll);
        Timer_ReSet(&omacbook->acc_check_timer, 1000, onAccCheckTimer, omacbook);

        ModifyUIPageHook(MAIN_WINDOW_GOT_FOCUS_EVENT, onMainGotFocus, (LPARAM)omacbook, 1);
        ModifyUIPageHook(MAIN_WINDOW_LOST_FOCUS_EVENT, onMainLostFocus, (LPARAM)omacbook, 1);
      }
    }
    else {
      omacbook->catch_retry_count--;
      //DEBUG_PRINTF("\nonCatchTimer: could not find Opera Mini book! (%d attempts left)\n", omacbook->catch_retry_count);                        ------------------------------------------------------
      if(omacbook->catch_retry_count > 0)
        Timer_ReSet(&omacbook->catch_timer, 1000, onCatchTimer, omacbook);
      else
        omacbook->catch_timer = 0;
    }
  }
}


////////////////////////////////////////////////////////////////////////////////
// Event hooks
int onSessionCreated(void * mess, BOOK * book) {
  OMAC_BOOK * omacbook = (OMAC_BOOK*)book;
//  DEBUG_PRINTF("\nELF: onSESSION_CREATED_EVENT\n");                        ------------------------------------------------------
  if(omacbook) {
    if(omacbook->hook)
      return 0;
    BOOK * b = FindBook(isCUIDisplayableBook);
    if(b) {
      char s[100];
      TextID_GetString(BookObj_GetSession(b)->name, s, MAXELEMS(s));
      //DEBUG_PRINTF("\nSESSION_CREATED_EVENT: %s\n", s);                        ------------------------------------------------------
      if(!strcmp(s, "SemcOjexInvoker")) {
        omacbook->catch_retry_count = 5;
        Timer_ReSet(&omacbook->catch_timer, 1000, onCatchTimer, omacbook);
      }
    }
  }
  return 0;
}

int onMainGotFocus(void * msg, BOOK * book, PAGE_DESC * page_desc, LPARAM _omacbook, u16) {
  OMAC_BOOK * omacbook = (OMAC_BOOK*)_omacbook;
  if(omacbook && omacbook->hook && !omacbook->acc_check_timer && omacbook->hook->book == book) {
    ACCELEROMETER_Open(omacbook->acc_dll);
    Timer_ReSet(&omacbook->acc_check_timer, 100, onAccCheckTimer, omacbook);
    //DEBUG_PRINTF("\nELF: resume OMAC\n");                        ------------------------------------------------------
  }
  return 0;
}

int onMainLostFocus(void * msg, BOOK * book, PAGE_DESC * page_desc, LPARAM _omacbook, u16) {
  OMAC_BOOK * omacbook = (OMAC_BOOK*)_omacbook;
  if(omacbook && omacbook->hook && omacbook->acc_check_timer && omacbook->hook->book == book) {
    Timer_Kill(&omacbook->acc_check_timer);
    ACCELEROMETER_Close(omacbook->acc_dll);
    //DEBUG_PRINTF("\nELF: pause OMAC\n");                        ----------------------------------------------
  }
  return 0;
}


////////////////////////////////////////////////////////////////////////////////
// Various methods
void ChangeMode(OMAC_BOOK * b) {
  if(b->hook) {
    DISP_OBJ_ONKEY_METHOD send = b->hook->defOnKey;
    GUI * gui = BOOK_GetTopGUI(b->hook->book);
    DISP_OBJ * dobj = GUIObject_GetDispObject(gui);
    send(dobj, KEY_STAR, 0, 1, KBD_SHORT_PRESS);
    send(dobj, KEY_STAR, 0, 1, KBD_SHORT_RELEASE);
    send(dobj, KEY_DIEZ, 0, 1, KBD_SHORT_PRESS);
    send(dobj, KEY_DIEZ, 0, 1, KBD_SHORT_RELEASE);
  }
}

void sendkey(OMAC_BOOK * b, int key, int mode) {
  //DEBUG_PRINTF("\nsendkey: %d\n", key);          --------------------------------------
  if(b->hook) {
    DISP_OBJ_ONKEY_METHOD send = b->hook->defOnKey;
    GUI * gui = BOOK_GetTopGUI(b->hook->book);
    DISP_OBJ * dobj = GUIObject_GetDispObject(gui);
    send(dobj, key, 0, 1, mode);
  }
}

void onAccCheckTimer(u16, LPARAM data) {
  OMAC_BOOK * b = (OMAC_BOOK*)data;
  int x, y, z;

  if(ACCELEROMETER_GetCoords(b->acc_dll, &x, &y, &z, 1) >= 0) {

    if(b->isTiltScrollActivated) {
      //change orientation?
      if(b->isHorizontal && x < 20 && y > 200 || !b->isHorizontal && y < 20 && x > 200) {
        b->isHorizontal = !b->isHorizontal;
        ChangeMode(b);
        // Delay, so that it won't change again within 1 second...
        Timer_ReSet(&b->acc_check_timer, 1000, onAccCheckTimer, data);
      }
      else {
        if(b->usingz) {
          if(b->isHorizontal)x = b->tilt - z;
          else               y = b->tilt - z;
        } else {
          if(b->isHorizontal)x -= b->tilt;
          else               y -= b->tilt;
        }
        
        x /= (18*2); // maybe not that optimal...
        y /= (18*2);
        
        if(x > 3) {
          if(b->scroll == SCROLL_NO_SCROLL || b->scroll == SCROLL_RIGHT) {
            sendkey(b, KEY_LEFT, KBD_SHORT_PRESS);
            b->scroll = SCROLL_LEFT;
          }
        }
        else if(x < -3) { // sensitivity difference as |a-b| != |b-a| ?
          if(b->scroll == SCROLL_NO_SCROLL || b->scroll == SCROLL_LEFT) {
            sendkey(b, KEY_RIGHT, KBD_SHORT_PRESS);
            b->scroll = SCROLL_RIGHT;
          }
        }
        else if(b->scroll == SCROLL_LEFT || b->scroll == SCROLL_RIGHT) {
          sendkey(b, (b->scroll==SCROLL_LEFT)?KEY_LEFT:KEY_RIGHT, KBD_LONG_RELEASE);
          b->scroll = SCROLL_NO_SCROLL;
        }
  
        if(y > 3) {
          if(b->scroll == SCROLL_NO_SCROLL || b->scroll == SCROLL_UP) {
            sendkey(b, KEY_DOWN, KBD_SHORT_PRESS);
            b->scroll = SCROLL_DOWN;
          }
        }
        else if(y < -3) { // sensitivity difference as |a-b| != |b-a| ?
          if(b->scroll == SCROLL_NO_SCROLL || b->scroll == SCROLL_DOWN) {
            sendkey(b, KEY_UP, KBD_SHORT_PRESS);
            b->scroll = SCROLL_UP;
          }
        }
        else if(b->scroll == SCROLL_DOWN || b->scroll == SCROLL_UP) {
          sendkey(b, (b->scroll==SCROLL_DOWN)?KEY_DOWN:KEY_UP, KBD_LONG_RELEASE);
          b->scroll = SCROLL_NO_SCROLL;
        }
      }
    }
    else { // (!b->isTiltScrollActivated)
      if(b->isHorizontal && y > 800 || !b->isHorizontal && x > 800) {
        b->isHorizontal = !b->isHorizontal;
        ChangeMode(b);
        // Delay, so that it won't change again within 1 second...
        Timer_ReSet(&b->acc_check_timer, 1000, onAccCheckTimer, data);
        return;
      }
    }
  } //else DEBUG_PRINTF("\nonAccCheckTimer: Could not get accelerometer data!\n");  ---------------------------------------------

  Timer_ReSet(&b->acc_check_timer, 200, onAccCheckTimer, data);
}


////////////////////////////////////////////////////////////////////////////////
// Page event methods
static int onTerminate(void *, BOOK * book) {
  FreeBook(book);
  return 1;
}

static int onAuthorInfo(void * mess, BOOK * book) {
  //CSTRMSGB(STR_ABOUT, *(BOOK**)mess);                        ------------------------------------------------------
  return 1;
}

////////////////////////////////////////////////////////////////////////////////
// Base page
const PAGE_MSG HW_PageEvents[] @ "DYN_PAGE" = {
  SESSION_CREATED_EVENT_TAG, onSessionCreated,
  ELF_TERMINATE_EVENT, onTerminate,
  ELF_SHOW_INFO_EVENT, onAuthorInfo,
  NIL_EVENT_TAG,       NULL
};

PAGE_DESC base_page ={"HW_BasePage", 0, HW_PageEvents};

////////////////////////////////////////////////////////////////////////////////
// Book methods
static void onCloseBook(BOOK * book) {
  OMAC_BOOK * omacbook = (OMAC_BOOK*)book;
  if(omacbook) {
    if(ACCELEROMETER_IsOpen(omacbook->acc_dll))
      ACCELEROMETER_Close(omacbook->acc_dll);

    ModifyUIPageHook(MAIN_WINDOW_GOT_FOCUS_EVENT, onMainGotFocus, 0, 0);
    ModifyUIPageHook(MAIN_WINDOW_LOST_FOCUS_EVENT, onMainLostFocus, 0, 0);
    
    UnLoadDLL(omacbook->acc_dll);
    if(omacbook->acc_check_timer)
      Timer_Kill(&omacbook->acc_check_timer);
    if(omacbook->catch_timer)
      Timer_Kill(&omacbook->catch_timer);
    if(omacbook->hook)
      freeOMBookHook(omacbook->hook);
    SUBPROC(elf_exit);
  }
}

static OMAC_BOOK * CreateOMACBook(void) {
  ACCELEROMETER_DLL_DATA * acc_dll = (ACCELEROMETER_DLL_DATA*)LoadDLL(L"accelerometer.dll");

  if(INVALID(acc_dll)) {
    //char s[100];
    //PRINTFMSG(s, "Failed to load accelerometer.dll! (DLL_ERROR=%d)", acc_dll); --------------------------------------------
    return NULL;
  }

  if(ACCELEROMETER_Version(acc_dll) < ACCELEROMETER_DLL_VERSION_NUMBER) {
    UnLoadDLL(acc_dll);
    //CSTRMSG("You are using an outdated accelerometer.dll!\n\n" ----------------------------------------------------------------
           // "Please update it to the latest version!");
    return NULL;
  }

  if(!ACCELEROMETER_IsPhoneSupported(acc_dll)) {
    UnLoadDLL(acc_dll);
    //CSTRMSG("Your phone model is not supported!"); -----------------------------------------------------------
    return NULL;
  }

  OMAC_BOOK * bk = (OMAC_BOOK*)malloc(sizeof(OMAC_BOOK));
  memset(bk, 0, sizeof(OMAC_BOOK));
  if(!CreateBook((BOOK*)bk, onCloseBook, &base_page, ELF_NAME, -1, 0)) {
    mfree(bk);
    return NULL;
  }
  bk->acc_dll = acc_dll;
  
  onSessionCreated(0, (BOOK*)bk); // Attempt to find already existing Opera Mini instance
  
  return bk;
}


////////////////////////////////////////////////////////////////////////////////
// Main method

int main(void) {
  if(FindBook(isAnyOMACBook))
  {
//    CSTRMSG("Already running!");                        ------------------------------------------------------
  }
  else if(CreateOMACBook())
    return 0;
  SUBPROC(elf_exit);
  return 0;
}