#include "apricot.h"
#include "Timer.h"
#include "Window.h"
#include "Image.h"
#include "Application.h"
#include <Application.inc>
#ifdef __cplusplus
extern "C" {
#endif
#undef  my
#define inherited CWidget->
#define my  ((( PApplication) self)-> self)
#define var (( PApplication) self)
static void Application_HintTimer_handle_event( Handle, PEvent);
void
Application_init( Handle self, HV * profile)
{
        dPROFILE;
        int hintPause = pget_i( hintPause);
        Color hintColor = pget_i( hintColor), hintBackColor = pget_i( hintBackColor);
        SV * hintFont = pget_sv( hintFont);
        SV * sv;
        char * hintClass      = pget_c( hintClass);
        if ( prima_guts.application != NULL_HANDLE)
                croak( "Attempt to create more than one application instance");
        opt_set(optSystemDrawable);
        CDrawable-> init( self, profile);
        list_create( &var->  widgets, 16, 16);
        list_create( &var->  modalHorizons, 0, 8);
        prima_guts.application = self;
        if ( !apc_application_create( self))
                croak( "Error creating application");
/* Widget init */
        SvHV_Font( pget_sv( font), &Font_buffer, "Application::init");
        my-> set_font( self, Font_buffer);
        SvHV_Font( pget_sv( popupFont), &Font_buffer, "Application::init");
        my-> set_popup_font( self, Font_buffer);
        {
                AV * av = ( AV *) SvRV( pget_sv( designScale));
                SV ** holder = av_fetch( av, 0, 0);
                if ( holder)
                        var->  designScale. x = SvNV( *holder);
                else
                        warn("Array panic on 'designScale'");
                holder = av_fetch( av, 1, 0);
                if ( holder)
                        var->  designScale. y = SvNV( *holder);
                else
                        warn("Array panic on 'designScale'");
                pdelete( designScale);
        }
        var->  text = newSVpv("", 0);
        var->  hint = newSVpv("", 0);
        var->  hintAround.left = var-> hintAround.bottom = var->hintAround.right = var->hintAround.top = -1;
        opt_set( optModalHorizon);
        /* store extra info */
        {
                HV * hv = ( HV *) SvRV( var-> mate);
                (void) hv_store( hv, "PrinterClass",  12, newSVpv( pget_c( printerClass),  0), 0);
                (void) hv_store( hv, "PrinterModule", 13, newSVpv( pget_c( printerModule), 0), 0);
                (void) hv_store( hv, "HelpClass",     9,  newSVpv( pget_c( helpClass),     0), 0);
                (void) hv_store( hv, "HelpModule",    10, newSVpv( pget_c( helpModule),    0), 0);
        }
        {
                HV * profile = newHV();
                static Timer_vmt HintTimerVmt;
                pset_H( owner, self);
                pset_i( timeout, hintPause);
                pset_c( name, "HintTimer");
                var->  hintTimer = create_instance( "Prima::Timer");
                protect_object( var-> hintTimer);
                hv_clear( profile);
                memcpy( &HintTimerVmt, CTimer, sizeof( HintTimerVmt));
                HintTimerVmt. handle_event = Application_HintTimer_handle_event;
                (( PTimer) var->  hintTimer)-> self = &HintTimerVmt;
                pset_H( owner, self);
                pset_i( color, hintColor);
                pset_i( backColor, hintBackColor);
                pset_i( visible, 0);
                pset_i( selectable, 0);
                pset_i( showHint, 0);
                pset_c( name, "HintWidget");
                pset_sv( font, hintFont);
                var->  hintWidget = create_instance( hintClass);
                protect_object( var->  hintWidget);
                sv_free(( SV *) profile);
        }
        if ( SvOK( sv = pget_sv( accelItems)))
                my-> set_accelItems( self, sv);
        if ( SvOK( sv = pget_sv( popupItems)))
                my-> set_popupItems( self, sv);
        pdelete( accelTable);
        pdelete( accelItems);
        pdelete( popupItems);
        my-> set( self, profile);
        CORE_INIT_TRANSIENT(Application);
}
void
Application_done( Handle self)
{
        if ( self != prima_guts.application) return;
        unprotect_object( var-> hintTimer);
        unprotect_object( var-> hintWidget);
        list_destroy( &var->  modalHorizons);
        list_destroy( &var->  widgets);
        if ( var-> text ) SvREFCNT_dec( var-> text);
        if ( var-> hint ) SvREFCNT_dec( var-> hint);
        free( var-> helpContext);
        var-> accelTable = var-> hintWidget = var-> hintTimer = NULL_HANDLE;
        var-> helpContext = NULL;
        var-> hint = var-> text = NULL;
        apc_application_destroy( self);
        CDrawable-> done( self);
        prima_guts.application = NULL_HANDLE;
}
static Bool 
kill_all_objects( Handle self, Handle child, void * dummy)
{
        Object_destroy( child);
        return false;
}
void
Application_cleanup( Handle self)
{
        int i;
        for ( i = 0; i < var-> widgets. count; i++)
                Object_destroy( var-> widgets. items[i]);
        if ( var-> icon)
                my-> detach( self, var-> icon, true);
        var-> icon = NULL_HANDLE;
        my-> first_that_component( self, 0, (void*)kill_all_objects, NULL);
        CDrawable-> cleanup( self);
}
void
Application_set( Handle self, HV * profile)
{
        pdelete( bottom);
        pdelete( buffered);
        pdelete( capture);
        pdelete( centered);
        pdelete( clipOwner);
        pdelete( enabled);
        pdelete( focused);
        pdelete( geometry);
        pdelete( geomHeight);
        pdelete( geomSize);
        pdelete( geomWidth);
        pdelete( growMode);
        pdelete( height);
        pdelete( hintClass);
        pdelete( hintVisible);
        pdelete( layered);
        pdelete( left);
        pdelete( modalHorizon);
        pdelete( origin);
        pdelete( owner);
        pdelete( ownerBackColor);
        pdelete( ownerColor);
        pdelete( ownerFont);
        pdelete( ownerPalette);
        pdelete( ownerShowHint);
        pdelete( palette);
        pdelete( pack);
        pdelete( place);
        pdelete( printerClass);
        pdelete( printerModule);
        pdelete( helpClass);
        pdelete( helpModule);
        pdelete( rect);
        pdelete( right);
        pdelete( selectable);
        pdelete( shape);
        pdelete( size);
        pdelete( syncPaint);
        pdelete( tabOrder);
        pdelete( tabStop);
        pdelete( transparent);
        pdelete( text);
        pdelete( top);
        pdelete( visible);
        pdelete( width);
        inherited set( self, profile);
}
void Application_handle_event( Handle self, PEvent event)
{
        switch ( event-> cmd)
        {
                case cmPost:
                        if ( event-> gen. H != self)
                        {
                                ((( PComponent) event-> gen. H)-> self)-> message( event-> gen. H, event);
                                event-> cmd = 0;
                                if ( var->  stage > csNormal) return;
                        }
                        break;
                case cmIdle:
                        my-> notify( self, "<s", "Idle");
                        return;
        }
        inherited handle_event ( self, event);
}
void
Application_sync( char * dummy)
{
        apc_application_sync();
}
Bool
Application_yield( char * dummy, Bool wait_for_event)
{
        return apc_application_yield(wait_for_event);
}
Bool
Application_begin_paint( Handle self)
{
        Bool ok;
        if ( !CDrawable-> begin_paint( self))
                return false;
        if ( !( ok = apc_application_begin_paint( self))) {
                CDrawable-> end_paint( self);
                perl_error();
        }
        return ok;
}
Bool
Application_begin_paint_info( Handle self)
{
        Bool ok;
        if ( is_opt( optInDraw))     return true;
        if ( !CDrawable-> begin_paint_info( self))
                return false;
        if ( !( ok = apc_application_begin_paint_info( self))) {
                CDrawable-> end_paint_info( self);
                perl_error();
        }
        return ok;
}
void
Application_detach( Handle self, Handle objectHandle, Bool kill)
{
        inherited detach( self, objectHandle, kill);
        if ( var->  autoClose &&
                ( var->  widgets. count == 1) &&
                kind_of( objectHandle, CWidget) &&
                ( objectHandle != var->  hintWidget)
                ) my-> close( self);
}
void
Application_end_paint( Handle self)
{
        if ( !is_opt( optInDraw)) return;
        apc_application_end_paint( self);
        CDrawable-> end_paint( self);
}
void
Application_end_paint_info( Handle self)
{
        if ( !is_opt( optInDrawInfo)) return;
        apc_application_end_paint_info( self);
        CDrawable-> end_paint_info( self);
}
Bool
Application_focused( Handle self, Bool set, Bool focused)
{
        if ( set) return false;
        return inherited focused( self, set, focused);
}
void Application_bring_to_front( Handle self) {}
void Application_show( Handle self) {}
void Application_hide( Handle self) {}
void Application_insert_behind( Handle self, Handle view) {}
void Application_send_to_back( Handle self) {}
SV*
Application_fonts( Handle self, char * name, char * encoding)
{
        int count, i;
        AV * glo = newAV();
        PFont fmtx = apc_fonts( self,
                (name && name[0])         ? name : NULL,
                (encoding && encoding[0]) ? encoding : NULL,
                &count);
        for ( i = 0; i < count; i++) {
                SV * sv      = sv_Font2HV( &fmtx[ i]);
                HV * profile = ( HV*) SvRV( sv);
                if ( fmtx[i].is_utf8.name ) {
                        SV ** entry = hv_fetch(( HV*) SvRV( sv), "name", 4, 0);
                        if ( entry && SvOK( *entry))
                                SvUTF8_on( *entry);
                }
                if ( fmtx[i].is_utf8.family ) {
                        SV ** entry = hv_fetch(( HV*) SvRV( sv), "family", 6, 0);
                        if ( name && SvOK( *entry))
                                SvUTF8_on( *entry);
                }
                if ( fmtx[i].is_utf8.encoding ) {
                        SV ** entry = hv_fetch(( HV*) SvRV( sv), "encoding", 8, 0);
                        if ( name && SvOK( *entry))
                                SvUTF8_on( *entry);
                }
                if ( name[0] == 0 && encoding[0] == 0) {
                        /* Read specially-coded (const char*) encodings[] vector,
                        stored in fmtx[i].encoding. First pointer is filled with 0s,
                        except the last byte which is a counter. Such scheme
                        allows max 31 encodings per entry to be coded with sizeof(char*)==8.
                        The interface must be re-implemented, but this requires
                        either change in gencls syntax so arrays can be members of hashes,
                        or passing of a dynamic-allocated pointer vector here.
                        */
                        char ** enc = (char**) fmtx[i].encoding;
                        unsigned char * shift = (unsigned char*) enc + sizeof(char *) - 1, j = *shift;
                        AV * loc = newAV();
                        pset_sv_noinc( encoding, newSVpv(( j > 0) ? *(++enc) : "", 0));
                        while ( j--) av_push( loc, newSVpv(*(enc++),0));
                        pset_sv_noinc( encodings, newRV_noinc(( SV*) loc));
                }
                pdelete( resolution);
                pdelete( codepage);
                av_push( glo, sv);
        }
        free( fmtx);
        return newRV_noinc(( SV *) glo);
}
SV*
Application_font_mapper_action( char * dummy, HV * profile)
{
        dPROFILE;
        SV * ret = NULL_SV;
        char * command;
        int cmd;
        Font font;
        if ( !pexist(command) ) {
                warn("command expected");
                goto EXIT;
        }
        command = pget_c(command);
        if ( strcmp(command, "get_font") == 0 ) {
                PFont f;
                if ( !pexist(index) ) {
                        warn("index expected");
                        goto EXIT;
                }
                f = prima_font_mapper_get_font(pget_i(index));
                if (!f) goto EXIT;
                ret = sv_Font2HV( f );
        } else if ( strcmp(command, "get_count") == 0 ) {
                ret = newSViv( prima_font_mapper_action(pfmaGetCount, NULL));
        } else if (
                ((strcmp(command, "disable")    == 0 ) && (cmd = pfmaIsActive )) ||
                ((strcmp(command, "enable")     == 0 ) && (cmd = pfmaPassivate)) ||
                ((strcmp(command, "is_enabled") == 0 ) && (cmd = pfmaActivate )) ||
                ((strcmp(command, "passivate")  == 0 ) && (cmd = pfmaIsEnabled)) ||
                ((strcmp(command, "activate")   == 0 ) && (cmd = pfmaEnable   )) ||
                ((strcmp(command, "is_active")  == 0 ) && (cmd = pfmaDisable  )) ||
                ((strcmp(command, "get_index")  == 0 ) && (cmd = pfmaGetIndex ))
        ) {
                if ( !pexist(font) ) {
                        warn("font expected");
                        goto EXIT;
                }
                SvHV_Font(pget_sv(font), &font, "Application::font_mapper");
                ret = newSViv( prima_font_mapper_action(cmd, &font));
        } else {
                warn("unknown command");
        }
EXIT:
        hv_clear(profile);
        return ret;
}
SV*
Application_font_encodings( Handle self)
{
        AV * glo = newAV();
        HE *he;
        PHash h = apc_font_encodings( self);
        if ( !h) return newRV_noinc(( SV *) glo);
        hv_iterinit(( HV*) h);
        for (;;)
        {
                void *key;
                STRLEN  keyLen;
                if (( he = hv_iternext( h)) == NULL)
                        break;
                key    = HeKEY( he);
                keyLen = HeKLEN( he);
                av_push( glo, newSVpvn(( char*) key, keyLen));
        }
        return newRV_noinc(( SV *) glo);
}
Font
Application_get_default_font( char * dummy)
{
        Font font;
        apc_font_default( &font);
        return font;
}
Font
Application_get_message_font( char * dummy)
{
        Font font;
        apc_sys_get_msg_font( &font);
        return font;
}
Font
Application_get_caption_font( char * dummy)
{
        Font font;
        apc_sys_get_caption_font( &font);
        return font;
}
int
Application_get_default_cursor_width( char * dummy)
{
        return apc_sys_get_value( svXCursor);
}
Point
Application_get_default_scrollbar_metrics( char * dummy)
{
        Point ret;
        ret. x = apc_sys_get_value( svXScrollbar);
        ret. y = apc_sys_get_value( svYScrollbar);
        return ret;
}
Point
Application_get_default_window_borders( char * dummy, int borderStyle)
{
        Point ret = { 0,0};
        switch ( borderStyle) {
        case bsNone:
                ret.x = svXbsNone;
                ret.y = svYbsNone;
                break;
        case bsSizeable:
                ret.x = svXbsSizeable;
                ret.y = svYbsSizeable;
                break;
        case bsSingle:
                ret.x = svXbsSingle;
                ret.y = svYbsSingle;
                break;
        case bsDialog:
                ret.x = svXbsDialog;
                ret.y = svYbsDialog;
                break;
        default:
                return ret;
        }
        ret. x = apc_sys_get_value( ret. x);
        ret. y = apc_sys_get_value( ret. y);
        return ret;
}
int
Application_get_system_value( char * dummy, int sysValue)
{
        return apc_sys_get_value( sysValue);
}
SV *
Application_get_system_info( char * dummy)
{
        HV * profile = newHV();
        char system   [ 1024];
        char release  [ 1024];
        char vendor   [ 1024];
        char arch     [ 1024];
        char gui_desc [ 1024];
        char gui_lang [ 1024];
        int  os, gui;
        os  = apc_application_get_os_info( system, sizeof( system),
                                        release, sizeof( release),
                                        vendor, sizeof( vendor),
                                        arch, sizeof( arch));
        gui = apc_application_get_gui_info( gui_desc, sizeof( gui_desc), gui_lang, sizeof(gui_lang));
        pset_i( apc,            os);
        pset_i( gui,            gui);
        pset_c( system,         system);
        pset_c( release,        release);
        pset_c( vendor,         vendor);
        pset_c( architecture,   arch);
        pset_c( guiDescription, gui_desc);
        pset_c( guiLanguage,    gui_lang);
        return newRV_noinc(( SV *) profile);
}
Handle
Application_get_widget_from_handle( Handle self, SV * handle)
{
        ApiHandle apiHandle;
        if ( SvIOK( handle))
                apiHandle = SvUVX( handle);
        else
                apiHandle = sv_2uv( handle);
        return apc_application_get_handle( self, apiHandle);
}
Handle
Application_get_hint_widget( Handle self)
{
        return var->  hintWidget;
}
static Bool
propagate_skin( Handle owner, Handle self, void * dummy)
{
        my-> set_skin( self, var-> skin);
        return false;
}
SV *
Application_skin( Handle self, Bool set, SV *skin)
{
        if ( !set) {
                return newSVsv(var->skin);
        } else if ( var-> stage <= csFrozen) {
                if ( var-> skin == skin) {
                        my-> first_that( self, (void*)propagate_skin, NULL);
                        return NULL_SV;
                }
                if ( var-> skin )
                        sv_free( var-> skin );
                var-> skin = SvOK( skin ) ? newSVsv(skin) : newSVpv("default", 0);
                my-> first_that( self, (void*)propagate_skin, NULL);
        }
        return NULL_SV;
}
static Bool
icon_notify ( Handle self, Handle child, Handle icon)
{
        if ( kind_of( child, CWindow) && (( PWidget) child)-> options. optOwnerIcon) {
                CWindow( child)-> set_icon( child, icon);
                PWindow( child)-> options. optOwnerIcon = 1;
        }
        return false;
}
Handle
Application_icon( Handle self, Bool set, Handle icon)
{
        if ( var-> stage > csFrozen) return NULL_HANDLE;
        if ( !set)
                return var-> icon;
        if ( icon && !kind_of( icon, CImage)) {
                warn("Illegal object reference passed to Application::icon");
                return NULL_HANDLE;
        }
        if ( icon) {
                icon = ((( PImage) icon)-> self)-> dup( icon);
                ++SvREFCNT( SvRV((( PAnyObject) icon)-> mate));
        }
        my-> first_that( self, (void*)icon_notify, (void*)icon);
        if ( var-> icon)
                my-> detach( self, var-> icon, true);
        var-> icon = icon;
        if ( icon && ( list_index_of( var-> components, icon) < 0))
                my-> attach( self, icon);
        return NULL_HANDLE;
}
Handle
Application_get_focused_widget( Handle self)
{
        return apc_widget_get_focused();
}
Handle
Application_get_active_window( Handle self)
{
        return apc_window_get_active();
}
Bool
Application_autoClose( Handle self, Bool set, Bool autoClose)
{
        if ( !set)
                return var->  autoClose;
        return var-> autoClose = autoClose;
}
SV *
Application_sys_action( char * dummy, char * params)
{
        char * i = apc_system_action( params);
        SV * ret = i ? newSVpv( i, 0) : NULL_SV;
        free( i);
        return ret;
}
typedef struct _SingleColor
{
        Color color;
        int   index;
} SingleColor, *PSingleColor;
Color
Application_colorIndex( Handle self, Bool set, int index, Color color)
{
        if ( var->  stage > csFrozen) return clInvalid;
        if (( index < 0) || ( index > ciMaxId)) return clInvalid;
        if ( !set) {
                switch ( index) {
                case ciFore:
                        return opt_InPaint ?
                                CDrawable-> get_color ( self) : var-> colors[ index];
                case ciBack:
                        return opt_InPaint ?
                                CDrawable-> get_backColor ( self) : var-> colors[ index];
                default:
                        return  var->  colors[ index];
                }
        } else {
                SingleColor s;
                s. color = color;
                s. index = index;
                if ( !opt_InPaint) my-> first_that( self, (void*)prima_single_color_notify, &s);
                if ( opt_InPaint) switch ( index) {
                        case ciFore:
                                CDrawable-> set_color ( self, color);
                                break;
                        case ciBack:
                                CDrawable-> set_backColor ( self, color);
                                break;
                }
                var-> colors[ index] = color;
        }
        return clInvalid;
}
void
Application_set_font( Handle self, Font font)
{
        if ( !opt_InPaint) my-> first_that( self, (void*)prima_font_notify, &font);
        apc_font_pick( self, &font, & var-> font);
        opt_clear(optFontTrigCache);
        if ( opt_InPaint) apc_gp_set_font ( self, &var-> font);
}
Bool
Application_close( Handle self)
{
        if ( var->  stage > csNormal) return true;
        return my-> can_close( self) ? ( apc_application_close( self), true) : false;
}
Bool
Application_insertMode( Handle self, Bool set, Bool insMode)
{
        if ( !set)
                return apc_sys_get_insert_mode();
        return apc_sys_set_insert_mode( insMode);
}
Handle
Application_get_modal_window( Handle self, int modalFlag, Bool topMost)
{
        if ( modalFlag == mtExclusive) {
                return topMost ? var-> topExclModal   : var-> exclModal;
        } else if ( modalFlag == mtShared) {
                return topMost ? var-> topSharedModal : var-> sharedModal;
        }
        return NULL_HANDLE;
}
SV *
Application_get_monitor_rects( Handle self)
{
        int i, nrects;
        Box * rects = apc_application_get_monitor_rects(self, &nrects);
        AV * ret = newAV();
        for ( i = 0; i < nrects; i++) {
                AV * rect = newAV();
                av_push( rect, newSViv( rects[i].x));
                av_push( rect, newSViv( rects[i].y));
                av_push( rect, newSViv( rects[i].width));
                av_push( rect, newSViv( rects[i].height));
                av_push( ret, newRV_noinc(( SV *) rect));
        }
        free(rects);
        /* .. or return at least the current size */
        if ( nrects == 0) {
                AV * rect = newAV();
                Point sz = apc_application_get_size(self);
                av_push( rect, newSViv( 0));
                av_push( rect, newSViv( 0));
                av_push( rect, newSViv( sz.x));
                av_push( rect, newSViv( sz.y));
                av_push( ret, newRV_noinc(( SV *) rect));
        }
        return newRV_noinc(( SV *) ret);
}
Handle
Application_get_parent( Handle self)
{
        return NULL_HANDLE;
}
Point
Application_get_scroll_rate( Handle self)
{
        Point ret;
        ret. x = apc_sys_get_value( svAutoScrollFirst);
        ret. y = apc_sys_get_value( svAutoScrollNext);
        return ret;
}
static void
hshow( Handle self)
{
        PWidget_vmt hintUnder = CWidget( var->  hintUnder);
        SV * text = hintUnder-> get_hint( var->  hintUnder);
        Point size;
        Point s = my-> get_size( self);
        Point fin = {0,0};
        Point pos = fin;
        Point mouse = my-> get_pointerPos( self);
        Point hintSize;
        PWidget_vmt hintWidget = CWidget( var->  hintWidget);
        if (
                var-> hintAround.left   == -1 &&
                var-> hintAround.bottom == -1 &&
                var-> hintAround.right  == -1 &&
                var-> hintAround.top    == -1
        ) {
                size = hintUnder-> get_size( var->  hintUnder);
                apc_widget_map_points( var-> hintUnder, true, 1, &pos);
        } else {
                pos.x  = var->hintAround.left;
                pos.y  = var->hintAround.bottom;
                size.x = var->hintAround.right - pos.x;
                size.y = var->hintAround.top   - pos.y;
        }
        hintWidget-> set_text( var->  hintWidget, text);
        hintSize = hintWidget-> get_size( var->  hintWidget);
        fin. x = mouse. x - 16;
        fin. y = pos. y - hintSize. y - 1;
        if ( fin. y > mouse. y - hintSize. y - 32) fin. y = mouse. y - hintSize. y - 32;
        if ( fin. x + hintSize. x >= s. x) fin. x = pos. x - hintSize. x;
        if ( fin. x < 0) fin. x = 0;
        if ( fin. y + hintSize. y >= s. y) fin. y = pos. y - hintSize. y;
        if ( fin. y < 0) fin. y = pos. y + size. y + 16;
        if ( fin. y < 0) fin. y = 0;
        hintWidget-> set_origin( var->  hintWidget, fin);
        hintWidget-> show( var->  hintWidget);
        hintWidget-> bring_to_front( var->  hintWidget);
}
void
Application_HintTimer_handle_event( Handle timer, PEvent event)
{
        CComponent-> handle_event( timer, event);
        if ( event-> cmd == cmTimer) {
                Handle self = prima_guts.application;
                CTimer(timer)-> stop( timer);
                if ( var->  hintActive == 1) {
                        Event ev = {cmHint};
                        if (   !var->hintUnder
                                || apc_application_get_widget_from_point( self, my-> get_pointerPos(self)) != var->hintUnder
                                || PObject( var-> hintUnder)-> stage != csNormal)
                                return;
                        ev. gen. B = true;
                        ev. gen. H = var->  hintUnder;
                        var->  hintVisible = 1;
                        if (( PWidget( var->  hintUnder)-> stage == csNormal) &&
                                ( CWidget( var->  hintUnder)-> message( var->  hintUnder, &ev))) {
                                hshow( self);
                        }
                } else if ( var->  hintActive == -1)
                        var->  hintActive = 0;
        }
}
void
Application_set_hint_action( Handle self, Handle view, Bool show, Bool byMouse, Rect around)
{
        if ( var-> stage >= csFrozen) return;
        if ( show && !is_opt( optShowHint)) return;
        if ( show)
        {
                var->  hintUnder = view;
                if ( var->  hintActive == -1)
                {
                        Event ev = {cmHint};
                        ev. gen. B = true;
                        ev. gen. H = view;
                        ((( PTimer) var->  hintTimer)-> self)-> stop( var-> hintTimer);
                        var->  hintVisible = 1;
                        if (
                                ( PWidget( view)-> stage == csNormal) &&
                                ( CWidget( view)-> message( view, &ev))
                        ) {
                                var-> hintAround = around;
                                hshow( self);
                                var->  hintAround.left = var-> hintAround.bottom = var->hintAround.right = var->hintAround.top = -1;
                        }
                } else {
                        if ( !byMouse && var->  hintActive == 1) return;
                        CTimer( var->  hintTimer)-> start( var-> hintTimer);
                        var-> hintAround = around;
                }
                var->  hintActive = 1;
        } else {
                int oldHA = var->  hintActive;
                int oldHV = var->  hintVisible;
                if ( oldHA != -1)
                        ((( PTimer) var-> hintTimer)-> self)-> stop( var-> hintTimer);
                var->  hintAround.left = var-> hintAround.bottom = var->hintAround.right = var->hintAround.top = -1;
                if ( var->  hintVisible)
                {
                        Event ev = {cmHint};
                        ev. gen. B = false;
                        ev. gen. H = view;
                        var->  hintVisible = 0;
                        if (( PWidget( view)-> stage != csNormal) ||
                                ( CWidget( view)-> message( view, &ev)))
                                CWidget( var->  hintWidget)-> hide( var->  hintWidget);
                }
                if ( oldHA != -1) var->  hintActive = 0;
                if ( byMouse && oldHV) {
                        var->  hintActive = -1;
                        CTimer( var->  hintTimer)-> start( var->  hintTimer);
                }
        }
}
Color
Application_hintColor( Handle self, Bool set, Color hintColor)
{
        if ( !set)
                return CWidget( var-> hintWidget)-> get_color( var->  hintWidget);
        return CWidget( var->  hintWidget)-> set_color( var->  hintWidget, hintColor);
}
Color
Application_hintBackColor( Handle self, Bool set, Color hintBackColor)
{
        if ( !set)
                return CWidget( var->  hintWidget)-> get_backColor( var-> hintWidget);
        return CWidget( var->  hintWidget)-> set_backColor( var->  hintWidget, hintBackColor);
}
int
Application_hintPause( Handle self, Bool set, int hintPause)
{
        if ( !set)
                return CTimer( var->  hintTimer)-> get_timeout( var->  hintTimer);
        return CTimer( var->  hintTimer)-> set_timeout( var->  hintTimer, hintPause);
}
void
Application_set_hint_font( Handle self, Font hintFont)
{
        CWidget( var-> hintWidget)-> set_font( var->  hintWidget, hintFont);
}
Font
Application_get_hint_font( Handle self)
{
        return CWidget( var->  hintWidget)-> get_font( var->  hintWidget);
}
Bool
Application_showHint( Handle self, Bool set, Bool showHint)
{
        if ( !set)
                return inherited showHint( self, set, showHint);
        opt_assign( optShowHint, showHint);
        return false;
}
Handle Application_next( Handle self) { return self;}
Handle Application_prev( Handle self) { return self;}
Bool
Application_layered( Handle self, Bool set, Bool layered)
{
        return false;
}
SV *
Application_palette( Handle self, Bool set, SV * palette)
{
        return CDrawable-> palette( self, set, palette);
}
Handle
Application_top_frame( Handle self, Handle from)
{
        while ( from) {
                if (
                        kind_of( from, CWindow) && (
                        ( PWidget( from)-> owner == prima_guts.application) ||
                        !CWidget( from)-> get_clipOwner(from)
                ))
                        return from;
                from = PWidget( from)-> owner;
        }
        return prima_guts.application;
}
Handle
Application_get_image( Handle self, int x, int y, int xLen, int yLen)
{
        HV * profile;
        Handle i;
        Bool ret;
        Point sz;
        if ( var->  stage > csFrozen) return NULL_HANDLE;
        if ( x < 0 || y < 0 || xLen <= 0 || yLen <= 0) return NULL_HANDLE;
        sz = apc_application_get_size( self);
        if ( x + xLen > sz. x) xLen = sz. x - x;
        if ( y + yLen > sz. y) yLen = sz. y - y;
        if ( x >= sz. x || y >= sz. y || xLen <= 0 || yLen <= 0) return NULL_HANDLE;
        profile = newHV();
        i = Object_create( "Prima::Image", profile);
        sv_free(( SV *) profile);
        ret = apc_application_get_bitmap( self, i, x, y, xLen, yLen);
        --SvREFCNT( SvRV((( PAnyObject) i)-> mate));
        return ret ? i : NULL_HANDLE;
}
/*
* Cannot return NULL_HANDLE.
*/
Handle
Application_map_focus( Handle self, Handle from)
{
        Handle topFrame = my-> top_frame( self, from);
        Handle topShared;
        if ( var->  topExclModal)
                return ( topFrame == var->  topExclModal) ? from : var->  topExclModal;
        if ( !var->  topSharedModal && var->  modalHorizons. count == 0)
                return from; /* return from if no shared modals active */
        if ( topFrame == self) {
                if ( !var->  topSharedModal) return from;
                topShared = var->  topSharedModal;
        } else {
                Handle horizon =
                        ( !CWindow( topFrame)-> get_modalHorizon( topFrame)) ?
                        CWindow( topFrame)-> get_horizon( topFrame) : topFrame;
                if ( horizon == self)
                        topShared = var->  topSharedModal;
                else
                        topShared = PWindow( horizon)-> topSharedModal;
        }
        return ( !topShared || ( topShared == topFrame)) ? from : topShared;
}
static Handle
popup_win( Handle xTop)
{
        PWindow_vmt top = CWindow( xTop);
        if ( !top-> get_visible( xTop))
                top-> set_visible( xTop, 1);
        if ( top-> get_windowState( xTop) == wsMinimized)
                top-> set_windowState( xTop, wsNormal);
        top-> set_selected( xTop, 1);
        return xTop;
}
Handle
Application_popup_modal( Handle self)
{
        Handle ha = apc_window_get_active();
        Handle xTop;
        if ( var->  topExclModal) {
        /* checking exclusive modal chain */
                xTop = ( !ha || ( PWindow(ha)->modal == 0)) ? var->  exclModal : ha;
                while ( xTop) {
                        if ( PWindow(xTop)-> nextExclModal) {
                                CWindow(xTop)-> bring_to_front( xTop);
                                xTop = PWindow(xTop)-> nextExclModal;
                        } else {
                                return popup_win( xTop);
                        }
                }
        } else {
                if ( !var->  topSharedModal && var->  modalHorizons. count == 0)
                        return NULL_HANDLE; /* return from if no shared modals active */
                /* checking shared modal chains */
                if ( ha) {
                        xTop = ( PWindow(ha)->modal == 0) ? CWindow(ha)->get_horizon(ha) : ha;
                        if ( xTop == prima_guts.application) xTop = var->  sharedModal;
                } else
                        xTop = var->  sharedModal ? var->  sharedModal : var->  modalHorizons. items[ 0];
                while ( xTop) {
                        if ( PWindow(xTop)-> nextSharedModal) {
                                CWindow(xTop)-> bring_to_front( xTop);
                                xTop = PWindow(xTop)-> nextSharedModal;
                        } else {
                                return popup_win( xTop);
                        }
                }
        }
        return NULL_HANDLE;
}
Bool
Application_pointerVisible( Handle self, Bool set, Bool pointerVisible)
{
        if ( !set)
                return apc_pointer_get_visible( self);
        return apc_pointer_set_visible( self, pointerVisible);
}
Point
Application_size( Handle self, Bool set, Point size)
{
        if ( set) return size;
        return apc_application_get_size( self);
}
Point
Application_origin( Handle self, Bool set, Point origin)
{
        Point p = { 0, 0};
        return p;
}
Bool
Application_modalHorizon( Handle self, Bool set, Bool modalHorizon)
{
        return true;
}
Bool
Application_textDirection( Handle self, Bool set, Bool textDirection)
{
        if ( !set ) return var->textDirection;
        return var-> textDirection = textDirection;
}
#define UISCALING_STEP 4
double
Application_uiScaling( Handle self, Bool set, double uiScaling)
{
        if ( !set ) return var->uiScaling;
        if ( uiScaling < 0.00001 ) {
                Point res = my-> get_resolution(self);
                uiScaling  = (double)((int)((double) res.x/ (96.0/UISCALING_STEP) + 0.5)) / UISCALING_STEP; /* 96-143 = 1.5, 144-191 = 1.5 etc */
                if ( uiScaling < 0.25 ) uiScaling = 0.25;
        }
        return var-> uiScaling = uiScaling;
}
Bool
Application_wantUnicodeInput( Handle self, Bool set, Bool want_ui)
{
        if ( !set) return var-> wantUnicodeInput;
        if ( apc_sys_get_value( svCanUTF8_Input))
                var-> wantUnicodeInput = want_ui;
        return 0;
}
void   Application_update_sys_handle( Handle self, HV * profile) {}
Bool   Application_get_capture( Handle self) { return false; }
Bool   Application_set_capture( Handle self, Bool capture, Handle confineTo) { return false; }
void   Application_set_centered( Handle self, Bool x, Bool y) {}
Bool   Application_tabStop( Handle self, Bool set, Bool tabStop)       { return false; }
Bool   Application_selectable( Handle self, Bool set, Bool selectable) { return false; }
Handle Application_shape( Handle self, Bool set, Handle mask)          { return NULL_HANDLE; }
Bool   Application_syncPaint( Handle self, Bool set, Bool syncPaint)   { return false; }
Bool   Application_visible( Handle self, Bool set, Bool visible)       { return true; }
Bool   Application_buffered( Handle self, Bool set, Bool buffered)     { return false; }
Bool   Application_enabled( Handle self, Bool set, Bool enable)        { return true;}
int    Application_growMode( Handle self, Bool set, int flags)         { return 0; }
Bool   Application_hintVisible( Handle self, Bool set, Bool visible)   { return false; }
Handle Application_owner( Handle self, Bool set, Handle owner)         { return NULL_HANDLE; }
Bool   Application_ownerColor( Handle self, Bool set, Bool ownerColor) { return false; }
Bool   Application_ownerBackColor( Handle self, Bool set, Bool ownerBackColor) { return false; }
Bool   Application_ownerFont( Handle self, Bool set, Bool ownerFont)   { return false; }
Bool   Application_ownerShowHint( Handle self, Bool set, Bool ownerShowHint) { return false; }
Bool   Application_ownerSkin( Handle self, Bool set, Bool ownerSkin)   { return false; }
Bool   Application_ownerPalette( Handle self, Bool set, Bool ownerPalette) { return false; }
Bool   Application_clipChildren( Handle self, Bool set, Bool clip)   { return true; }
Bool   Application_clipOwner( Handle self, Bool set, Bool clip_by_children)   { return false; }
int    Application_tabOrder( Handle self, Bool set, int tabOrder)      { return 0; }
SV   * Application_get_text    ( Handle self)                          { return NULL_SV; }
void   Application_set_text    ( Handle self, SV * text)               { }
Bool   Application_transparent( Handle self, Bool set, Bool transparent) { return false; }
Bool   Application_validate_owner( Handle self, Handle * owner, HV * profile) { *owner = NULL_HANDLE; return true; }
#ifdef __cplusplus
}
#endif