#------------------------------------------------------------------------------ # /var/install/include/cuilib - script interface for libcui # # Creation: 2007-06-30 dv # Last update: $Id$ # # Copyright (c) 2007-@@YEAR@@ the eisfair team, team(at)eisfair(dot)org # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2 of the License, or # (at your option) any later version. #---------------------------------------------------------------------------- # special key codes KEY_ENTER=10 KEY_F1=265 KEY_F2=266 KEY_F3=267 KEY_F4=268 KEY_F5=269 KEY_F6=270 KEY_F7=271 KEY_F8=272 KEY_F9=273 KEY_F10=274 # ... to be continued # cui colors COLOR_BLACK=0 COLOR_RED=1 COLOR_GREEN=2 COLOR_BROWN=3 COLOR_BLUE=4 COLOR_MAGENTA=5 COLOR_CYAN=6 COLOR_LIGHTGRAY=7 COLOR_DARKGRAY=8 COLOR_LIGHTRED=9 COLOR_LIGHTGREEN=10 COLOR_YELLOW=11 COLOR_LIGHTBLUE=12 COLOR_LIGHTMAGENTA=13 COLOR_LIGHTCYAN=14 COLOR_WHITE=15 # text alignment ALIGN_CENTER=0 ALIGN_LEFT=1 ALIGN_RIGHT=2 # cui API codes API_MESSAGEBOX=0 API_WINDOWNEW=1 API_WINDOWCREATE=2 API_WINDOWDESTROY=3 API_WINDOWQUIT=4 API_WINDOWMODAL=5 API_WINDOWCLOSE=6 API_WINDOWSETHOOK=7 API_WINDOWGETCTRL=10 API_WINDOWGETDESKTOP=11 API_WINDOWMOVE=12 API_WINDOWGETWINDOWRECT=13 API_WINDOWGETCLIENTRECT=14 API_WINDOWSETTIMER=20 API_WINDOWKILLTIMER=21 API_WINDOWADDCOLSCHEME=30 API_WINDOWHASCOLSCHEME=31 API_WINDOWCOLSCHEME=32 API_WINDOWSETTEXT=40 API_WINDOWSETLTEXT=41 API_WINDOWSETRTEXT=42 API_WINDOWSETSTATUSTEXT=43 API_WINDOWSETLSTATUSTEXT=44 API_WINDOWSETRSTATUSTEXT=45 API_WINDOWGETTEXT=46 API_WINDOWTOTOP=50 API_WINDOWMAXIMIZE=51 API_WINDOWMINIMIZE=52 API_WINDOWHIDE=53 API_WINDOWENABLE=54 API_WINDOWSETFOCUS=55 API_WINDOWGETFOCUS=56 API_WINDOWINVALIDATE=60 API_WINDOWINVALIDATELAYOUT=61 API_WINDOWUPDATE=62 API_WINDOW_CURSES_LEAVE=70 API_WINDOW_CURSES_RESUME=71 API_WINDOW_SHELL_EXECUTE=72 API_LABELNEW=110 API_LABELSETCALLBACK=111 API_EDITNEW=100 API_EDITSETCALLBACK=101 API_EDITSETTEXT=102 API_EDITGETTEXT=103 API_BUTTONNEW=120 API_BUTTONSETCALLBACK=121 API_GROUPBOXNEW=125 API_RADIONEW=130 API_RADIOSETCALLBACK=131 API_RADIOSETCHECK=132 API_RADIOGETCHECK=133 API_CHECKBOXNEW=135 API_CHECKBOXSETCALLBACK=136 API_CHECKBOXSETCHECK=137 API_CHECKBOXGETCHECK=138 API_LISTBOXNEW=140 API_LISTBOXSETCALLBACK=141 API_LISTBOXADD=142 API_LISTBOXDELETE=143 API_LISTBOXGET=144 API_LISTBOXSETDATA=145 API_LISTBOXGETDATA=146 API_LISTBOXSETSEL=147 API_LISTBOXGETSEL=148 API_LISTBOXCLEAR=149 API_LISTBOXGETCOUNT=150 API_LISTBOXSELECT=151 API_COMBOBOXNEW=160 API_COMBOBOXSETCALLBACK=161 API_COMBOBOXADD=162 API_COMBOBOXDELETE=163 API_COMBOBOXGET=164 API_COMBOBOXSETDATA=165 API_COMBOBOXGETDATA=166 API_COMBOBOXSETSEL=167 API_COMBOBOXGETSEL=168 API_COMBOBOXCLEAR=169 API_COMBOBOXGETCOUNT=170 API_COMBOBOXSELECT=171 API_PROGRESSBARNEW=180 API_PROGRESSBARSETRANGE=181 API_PROGRESSBARSETPOS=182 API_PROGRESSBARGETRANGE=183 API_PROGRESSBARGETPOS=184 API_TEXTVIEWNEW=200 API_TEXTVIEWSETCALLBACK=201 API_TEXTVIEWENABLEWORDWRAP=202 API_TEXTVIEWADD=203 API_TEXTVIEWCLEAR=204 API_TEXTVIEWREAD=205 API_TEXTVIEWSEARCH=206 API_LISTVIEWNEW=210 API_LISTVIEWSETCALLBACK=211 API_LISTVIEWADDCOLUMN=212 API_LISTVIEWSETTITLEALIGNMENT=213 API_LISTVIEWCLEAR=214 API_LISTVIEWADD=215 API_LISTVIEWSETTEXT=216 API_LISTVIEWGETTEXT=217 API_LISTVIEWGETDATA=218 API_LISTVIEWSETDATA=219 API_LISTVIEWSETSEL=220 API_LISTVIEWGETSEL=221 API_LISTVIEWGETCOUNT=222 API_LISTVIEWUPDATE=223 API_LISTVIEWALPHASORT=224 API_LISTVIEWNUMERICSORT=225 API_LISTVIEWSETROWTEXT=226 API_LISTVIEWHILIGHT=227 API_TERMINALNEW=230 API_TERMINALSETCALLBACK=231 API_TERMINALWRITE=232 API_TERMINALRUN=233 API_TERMINALPIPEDATA=234 API_MENUNEW=240 API_MENUSETCALLBACK=241 API_MENUADDITEM=242 API_MENUADDSEPARATOR=243 API_MENUSELECTITEM=244 API_MENUGETSELITEM=245 API_MENUCLEAR=246 API_MEMONEW=250 API_MEMOSETCALLBACK=251 API_MEMOSETTEXT=252 API_MEMOGETTEXT=253 API_MEMOSETWRAPCOLUMNS=254 API_XMLREADTAG=500 API_LOADADDON=999 # cui error codes ERROR_SUCCESS=0 ERROR_PROTO=1 ERROR_UNKNWN=2 ERROR_ARGC=3 ERROR_INVALID=4 ERROR_FAILED=5 # Hook types HOOK_CREATE='0' HOOK_DESTROY='1' HOOK_CANCLOSE='2' HOOK_INIT='3' HOOK_PAINT='4' HOOK_NCPAINT='5' HOOK_SIZE='6' HOOK_SETFOCUS='7' HOOK_KILLFOCUS='8' HOOK_ACTIVATE='9' HOOK_DEACTIVATE='10' HOOK_KEY='11' HOOK_MMOVE='12' HOOK_MBUTTON='13' HOOK_VSCROLL='14' HOOK_HSCROLL='15' HOOK_TIMER='16' HOOK_LAYOUT='17' # Edit hook types EDIT_SETFOCUS='0' EDIT_KILLFOCUS='1' EDIT_PREKEY='2' EDIT_POSTKEY='3' EDIT_CHANGED='4' # Label hook types LABEL_SETFOCUS='0' LABEL_KILLFOCUS='1' # Button hook types BUTTON_SETFOCUS='0' BUTTON_KILLFOCUS='1' BUTTON_PREKEY='2' BUTTON_POSTKEY='3' BUTTON_CLICKED='4' # Radio hook types RADIO_SETFOCUS='0' RADIO_KILLFOCUS='1' RADIO_PREKEY='2' RADIO_POSTKEY='3' RADIO_CLICKED='4' # Checkbox hook types CHECKBOX_SETFOCUS='0' CHECKBOX_KILLFOCUS='1' CHECKBOX_PREKEY='2' CHECKBOX_POSTKEY='3' CHECKBOX_CLICKED='4' # Listbox hook types LISTBOX_SETFOCUS='0' LISTBOX_KILLFOCUS='1' LISTBOX_PREKEY='2' LISTBOX_POSTKEY='3' LISTBOX_CHANGED='4' LISTBOX_CHANGING='5' LISTBOX_CLICKED='6' # Combobox hook types COMBOBOX_SETFOCUS='0' COMBOBOX_KILLFOCUS='1' COMBOBOX_PREKEY='2' COMBOBOX_POSTKEY='3' COMBOBOX_CHANGED='4' COMBOBOX_CHANGING='5' # Textview hook types TEXTVIEW_SETFOCUS='0' TEXTVIEW_KILLFOCUS='1' TEXTVIEW_PREKEY='2' TEXTVIEW_POSTKEY='3' # Listview hook types LISTVIEW_SETFOCUS='0' LISTVIEW_KILLFOCUS='1' LISTVIEW_PREKEY='2' LISTVIEW_POSTKEY='3' LISTVIEW_CHANGED='4' LISTVIEW_CHANGING='5' LISTVIEW_CLICKED='6' # Terminal hook types TERMINAL_SETFOCUS='0' TERMINAL_KILLFOCUS='1' TERMINAL_PREKEY='2' TERMINAL_POSTKEY='3' TERMINAL_EXIT='4' # Menu hook types MENU_SETFOCUS='0' MENU_KILLFOCUS='1' MENU_PREKEY='2' MENU_POSTKEY='3' MENU_CHANGED='4' MENU_CHANGING='5' MENU_CLICKED='6' MENU_ESCAPE='7' # Memo hook types MEMO_SETFOCUS='0' MEMO_KILLFOCUS='1' MEMO_PREKEY='2' MEMO_POSTKEY='3' MEMO_CHANGED='4' # Window and control styles CWS_NONE='0' CWS_BORDER='1' CWS_CAPTION='2' CWS_MINIMIZEBOX='4' CWS_MAXIMIZEBOX='8' CWS_CLOSEBOX='16' CWS_SYSMENU='32' CWS_RESIZE='64' CWS_HIDDEN='256' CWS_DISABLED='512' CWS_TABSTOP='1024' CWS_CENTERED='2048' CWS_POPUP='4096' CWS_MAXIMIZED='8192' CWS_MINIMIZED='16384' CWS_STATUSBAR='32768' CWS_DEFOK='65536' CWS_DEFCANCEL='131072' EF_PASSWORD='16777216' MF_AUTOWORDWRAP='16777216' LB_SORTED='16777216' LB_DESCENDING='33554432' # MessageBox styles MB_NORMAL='0' MB_INFO='16777216' MB_ERROR='33554432' MB_OK='0' MB_OKCANCEL='67108864' MB_YESNO='134217728' MB_YESNOCANCEL='268435456' MB_RETRYCANCEL='536870912' MB_DEFBUTTON1='1073741824' MB_DEFBUTTON2='2147483648' # Dialog result codes IDOK='1' IDCANCEL='2' IDYES='3' IDNO='4' IDRETRY='5' # Scroll bar control codes SB_LINEDOWN='1' SB_LINEUP='2' SB_PAGEDOWN='3' SB_PAGEUP='4' SB_THUMBTRACK='5' SEP=' ' SCRIPTFILE=$0 CUIID=$1 PARENTPID=$2 CUINL=$'\x0A' #' newline character CUISEP=$'\x09' #' tabulator / protocol seperator for arg in "${@}" do ARGUMENTS="${ARGUMENTS} \"${arg}\"" done #------------------------------------------------------------------------------ # Pipe initialisation # Expects: # Returns: #------------------------------------------------------------------------------ cui_init() { pipe_in="/run/cui/cui${PARENTPID}rp" pipe_out="/run/cui/cui${PARENTPID}wp" if [ "$CUIID" != "CUISHELL" ] then if [ -n "${ARGUMENTS}" ] then /var/install/bin/shellrun.cui -o "${ARGUMENTS}" "${SCRIPTFILE}" else /var/install/bin/shellrun.cui "${SCRIPTFILE}" fi exit $? else exec 7< $pipe_in exec 8> $pipe_out fi } #------------------------------------------------------------------------------ # Send data to frontend (escape \t \n and \\) # Expects: $1 .. $n <-- Parameters to send # Returns: #------------------------------------------------------------------------------ cui_send() { local val=":$1" local tmp="" local idx=2 while [ "$idx" -le "$#" ] do eval tmp='$'"{$idx//'\\\\'/'\\\\'}" tmp=${tmp//'\'/'\s'} tmp=${tmp//$CUISEP/'\t'} tmp=${tmp//$CUINL/'\n'} val="${val}${CUISEP}:$tmp" idx=$[$idx + 1] done echo "$val" >&8 } #------------------------------------------------------------------------------ # Send return from hook signal # Expects: $1 <-- Result data : one or more results # (enclosed in quotes if necessary) # Returns: #------------------------------------------------------------------------------ cui_return() { cui_send "H" "$@" } #------------------------------------------------------------------------------ # Main message polling loop # Expects: # Returns: #------------------------------------------------------------------------------ cui_run() { while [ "1" == "1" ] do { cmdline="" read -r cmdline } <&7 if [ -n "$cmdline" ] then cmdcount=0 OLD_IFS="$IFS" IFS=$SEP for cmd in $cmdline do # unescape parameter cmd=${cmd//'\n'/$CUINL} cmd=${cmd//'\t'/$CUISEP} cmd=${cmd//'\s'/'\'} # assign and remove colon eval 'p'$cmdcount='${cmd:1}' cmdcount=$[$cmdcount + 1] done IFS="$OLD_IFS" if [ "$cmdcount" -gt "0" -a "$p0" == "H" ] then if [ "$p1" == "exit" ] then cui_return 0 return; else $p1 fi fi else return; fi done } #------------------------------------------------------------------------------ # Wait for acknowledge from frontend (internal function) # Expects: # Returns: #------------------------------------------------------------------------------ cui_wait_ack() { while [ "1" == "1" ] do { cmdline="" read -r cmdline } <&7 if [ -n "$cmdline" ] then OLD_IFS="$IFS" IFS=$SEP cmdcount=0 for cmd in $cmdline do # unescape parameter cmd=${cmd//'\n'/$CUINL} cmd=${cmd//'\t'/$CUISEP} cmd=${cmd//'\s'/'\'} # assign and remove colon eval 'p'$cmdcount='${cmd:1}' cmdcount=$[$cmdcount + 1] done IFS="$OLD_IFS" if [ "$cmdcount" -gt "0" ] then if [ "$p0" == "R" ] then if [ "$cmdcount" -gt "1" ] then case $p1 in $ERROR_SUCCESS) return 0 ;; $ERROR_PROTO) cui_message 0 "Protocol error!" "Error" $MB_ERROR return 1 ;; $ERROR_UNKNWN) cui_message 0 "Unknown function called!" "Error" $MB_ERROR return 1 ;; $ERROR_ARGC) cui_message 0 "Invalid number of arguments!" "Error" $MB_ERROR return 1 ;; $ERROR_INVALID) cui_message 0 "Invalid arguments!" "Error" $MB_ERROR return 1 ;; $ERROR_FAILED) return 1 ;; *) cui_message 0 "Invalid reply!" "Error" $MB_ERROR return 1 ;; esac else cui_message 0 "Invalid reply!" "Error" $MB_ERROR return 1 fi elif [ "$p0" == "H" ] then $p1 fi fi else return 1; fi done } #---------------------------------------------------------------------------- # Check if $1 is a valid handle # Expects: $1 <-- Handle variable # Returns: exit code: (0 = Success, 1 = Failure) #---------------------------------------------------------------------------- cui_valid_handle() { if [ -n "$1" -a "$1" -ne "0" ] then return 0 fi return 1 } #---------------------------------------------------------------------------- # Check if $1 is a valid list index # Expects: $1 <-- Index variable # Returns: exit code: (0 = Success, 1 = Failure) #---------------------------------------------------------------------------- cui_valid_index() { if [ -n "$1" -a "$1" -ge "0" ] then return 0 fi return 1 } #------------------------------------------------------------------------------ # MessageBox # Expects: $1 <-- Parent window : Window Handle # $2 <-- Message : String # $3 <-- Title : String # $4 <-- Style : Integer (use $MB_XXX constants) # Returns: $p2 --> Result code : Integer #------------------------------------------------------------------------------ cui_message() { cui_send "C" "${API_MESSAGEBOX}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new window: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- X : Integer # $3 <-- Y : Integer # $4 <-- W : Integer # $5 <-- H : Integer # $6 <-- Style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_window_new() { cui_send "C" "${API_WINDOWNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Create window (and make it visible): # Expects: $1 <-- Window : Window Handle # Returns: #------------------------------------------------------------------------------ cui_window_create() { cui_send "C" "${API_WINDOWCREATE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Destroy window (and it's data): # Expects: $1 <-- Window : Window Handle # Returns: #------------------------------------------------------------------------------ cui_window_destroy() { cui_send "C" "${API_WINDOWDESTROY}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Quit application: # Expects: $1 <-- Exit code : Integer # Returns: #------------------------------------------------------------------------------ cui_window_quit() { cui_send "C" "${API_WINDOWQUIT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Execute as modal dialog # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Result code : Integer #------------------------------------------------------------------------------ cui_window_modal() { cui_send "C" "${API_WINDOWMODAL}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Close a modal dialog # Expects: $1 <-- Window : Window Handle # $2 <-- Result code : Integer # Returns: $p2 --> "1" success : "0" no success (refused to close) #------------------------------------------------------------------------------ cui_window_close() { cui_send "C" "${API_WINDOWCLOSE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a window hook # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_window_sethook() { cui_send "C" "${API_WINDOWSETHOOK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get a control window # Expects: $1 <-- Window : Window Handle # $2 <-- Ctrl ID : Integer # Returns: $p2 --> Ctrl : Window Handle or "0" if not found #------------------------------------------------------------------------------ cui_window_getctrl() { cui_send "C" "${API_WINDOWGETCTRL}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get desktop window # Expects: # Returns: $p2 --> Desktop : Window Handle #------------------------------------------------------------------------------ cui_getdesktop() { cui_send "C" "${API_WINDOWGETDESKTOP}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Move and/or resize a window # Expects: $1 <-- Window : Window Handle # $2 <-- X : Integer # $3 <-- Y : Integer # $4 <-- W : Integer # $5 <-- H : Integer # Returns: #------------------------------------------------------------------------------ cui_window_move() { cui_send "C" "${API_WINDOWMOVE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get a window's rectangle # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> X : Integer # $p3 --> Y : Integer # $p4 --> W : Integer # $p5 --> H : Integer #------------------------------------------------------------------------------ cui_getwindowrect() { cui_send "C" "${API_WINDOWGETWINDOWRECT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get a window's client rectangle # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> X : Integer # $p3 --> Y : Integer # $p4 --> W : Integer # $p5 --> H : Integer #------------------------------------------------------------------------------ cui_getclientrect() { cui_send "C" "${API_WINDOWGETCLIENTRECT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Start a window timer # Expects: $1 <-- Window : Window Handle # $2 <-- TimerId : Integer # $3 <-- Time : Integer (Milliseconds 100ms resolution) # Returns: #------------------------------------------------------------------------------ cui_settimer() { cui_send "C" "${API_WINDOWSETTIMER}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Stop a window timer # Expects: $1 <-- Window : Window Handle # $2 <-- TimerId : Integer # Returns: #------------------------------------------------------------------------------ cui_killtimer() { cui_send "C" "${API_WINDOWKILLTIMER}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Add/Modify a color profile # Expects: $1 <-- Name : Window Handle # $2 <-- WndColor : Integer (COLOR_XXX) # $3 <-- WndSelColor : Integer (COLOR_XXX) # $4 <-- WndTxtColor : Integer (COLOR_XXX) # $5 <-- SelTxtColor : Integer (COLOR_XXX) # $6 <-- InactTxtColor : Integer (COLOR_XXX) # $7 <-- HilightColor : Integer (COLOR_XXX) # $8 <-- TitleTxtColor : Integer (COLOR_XXX) # $9 <-- TitleBkgndColor : Integer (COLOR_XXX) # $10 <-- StatusTxtColor : Integer (COLOR_XXX) # $11 <-- StatusBkgndColor: Integer (COLOR_XXX) # $12 <-- BorderColor : Integer (COLOR_XXX) # Returns: #------------------------------------------------------------------------------ cui_addcolors() { cui_send "C" "${API_WINDOWADDCOLSCHEME}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Check if color profile has been defined # Expects: $1 <-- Name : Name of profile # returns: $p2 --> Result : Integer (0 = not defined, 1 = defined) #------------------------------------------------------------------------------ cui_hascolors() { cui_send "C" "${API_WINDOWHASCOLSCHEME}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a color profile to a window # Expects: $1 <-- Window : Window Handle # $2 <-- Nam e : Name of profile # returns: #------------------------------------------------------------------------------ cui_window_setcolors() { cui_send "C" "${API_WINDOWCOLSCHEME}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set window text # Expects: $1 <-- Window : Window Handle # $2 <-- Text : Window text # returns: #------------------------------------------------------------------------------ cui_window_settext() { cui_send "C" "${API_WINDOWSETTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set window left text # Expects: $1 <-- Window : Window Handle # $2 <-- Text : Window text # returns: #------------------------------------------------------------------------------ cui_window_setltext() { cui_send "C" "${API_WINDOWSETLTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set window right text # Expects: $1 <-- Window : Window Handle # $2 <-- Text : Window text # returns: #------------------------------------------------------------------------------ cui_window_setrtext() { cui_send "C" "${API_WINDOWSETRTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set window status text # Expects: $1 <-- Window : Window Handle # $2 <-- Text : Window text # returns: #------------------------------------------------------------------------------ cui_window_setstatustext() { cui_send "C" "${API_WINDOWSETSTATUSTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set window left status text # Expects: $1 <-- Window : Window Handle # $2 <-- Text : Window text # returns: #------------------------------------------------------------------------------ cui_window_setlstatustext() { cui_send "C" "${API_WINDOWSETLSTATUSTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set window right status text # Expects: $1 <-- Window : Window Handle # $2 <-- Text : Window text # returns: #------------------------------------------------------------------------------ cui_window_setrstatustext() { cui_send "C" "${API_WINDOWSETRSTATUSTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Bring window to top # Expects: $1 <-- Window : Window Handle # returns: #------------------------------------------------------------------------------ cui_window_totop() { cui_send "C" "${API_WINDOWTOTOP}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Maximize window (and reverse) # Expects: $1 <-- Window : Window Handle # $2 <-- State : 1 = maximize, 0 = normal # returns: #------------------------------------------------------------------------------ cui_window_maximize() { cui_send "C" "${API_WINDOWMAXIMIZE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Minimize window (and reverse) # Expects: $1 <-- Window : Window Handle # $2 <-- State : 1 = minimize, 0 = normal # returns: #------------------------------------------------------------------------------ cui_window_minimize() { cui_send "C" "${API_WINDOWMINIMIZE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Hide window (and reverse) # Expects: $1 <-- Window : Window Handle # $2 <-- State : 1 = hidden, 0 = visible # returns: #------------------------------------------------------------------------------ cui_window_hide() { cui_send "C" "${API_WINDOWHIDE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Enable window (and reverse) # Expects: $1 <-- Window : Window Handle # $2 <-- State : 1 = enabled (default), 0 = disabled # returns: #------------------------------------------------------------------------------ cui_window_enable() { cui_send "C" "${API_WINDOWENABLE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set the input focus to a window # Expects: $1 <-- Window : Window Handle # returns: #------------------------------------------------------------------------------ cui_window_setfocus() { cui_send "C" "${API_WINDOWSETFOCUS}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get the window that owns the input focus # Expects: # returns: $p2 --> Window : Window Handle #------------------------------------------------------------------------------ cui_window_getfocus() { cui_send "C" "${API_WINDOWGETFOCUS}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Invalidate window and force redrawing # Expects: $1 <-- Window : Window Handle # returns: #------------------------------------------------------------------------------ cui_window_invalidate() { cui_send "C" "${API_WINDOWINVALIDATE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Invalidate window layout an scrollbar sizes (i.e. when a listbox receives # data) # Expects: $1 <-- Window : Window Handle # returns: #------------------------------------------------------------------------------ cui_window_invalidate_layout() { cui_send "C" "${API_WINDOWINVALIDATELAYOUT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Update window stack # Expects: # returns: #------------------------------------------------------------------------------ cui_update() { cui_send "C" "${API_WINDOWUPDATE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Leave curses mode # Expects: # returns: #------------------------------------------------------------------------------ cui_leave_curses() { cui_send "C" "${API_WINDOW_CURSES_LEAVE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Resume curses mode # Expects: # returns: #------------------------------------------------------------------------------ cui_resume_curses() { cui_send "C" "${API_WINDOW_CURSES_RESUME}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Execute shell command # Expects: $1 <-- Shell command : String # returns: $p2 --> Exit code #------------------------------------------------------------------------------ cui_shell_execute() { cui_send "C" "${API_WINDOW_SHELL_EXECUTE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new edit: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Window title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- Len : Integer # $8 <-- ID : Integer # $9 <-- Set style : Integer (use $CWS_XXX constants) # $10 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_edit_new() { cui_send "C" "${API_EDITNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a edit callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_edit_callback() { cui_send "C" "${API_EDITSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set edit text # Expects: $1 <-- Window : Window Handle # $2 <-- Text : String # Returns: #------------------------------------------------------------------------------ cui_edit_settext() { cui_send "C" "${API_EDITSETTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get edit text # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Text : String #------------------------------------------------------------------------------ cui_edit_gettext() { cui_send "C" "${API_EDITGETTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new label: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Window title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- ID : Integer # $8 <-- Set style : Integer (use $CWS_XXX constants) # $9 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_label_new() { cui_send "C" "${API_LABELNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a label callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_label_callback() { cui_send "C" "${API_LABELSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new button: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Window title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- ID : Integer # $8 <-- Set style : Integer (use $CWS_XXX constants) # $9 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_button_new() { cui_send "C" "${API_BUTTONNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a button callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_button_callback() { cui_send "C" "${API_BUTTONSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new groupbox: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Window title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- Set style : Integer (use $CWS_XXX constants) # $8 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_groupbox_new() { cui_send "C" "${API_GROUPBOXNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new radio control: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Window title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- ID : Integer # $8 <-- Set style : Integer (use $CWS_XXX constants) # $9 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_radio_new() { cui_send "C" "${API_RADIONEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a radio callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_radio_callback() { cui_send "C" "${API_RADIOSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set radio check status # Expects: $1 <-- Window : Window Handle # $2 <-- Value : Integer (0 or 1) # Returns: #------------------------------------------------------------------------------ cui_radio_setcheck() { cui_send "C" "${API_RADIOSETCHECK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get radio check status # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Value : Integer (0 or 1) #------------------------------------------------------------------------------ cui_radio_getcheck() { cui_send "C" "${API_RADIOGETCHECK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new checkbox control: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Window title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- ID : Integer # $8 <-- Set style : Integer (use $CWS_XXX constants) # $9 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_checkbox_new() { cui_send "C" "${API_CHECKBOXNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a checkbox callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_checkbox_callback() { cui_send "C" "${API_CHECKBOXSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set checkbox check status # Expects: $1 <-- Window : Window Handle # $2 <-- Value : Integer (0 or 1) # Returns: #------------------------------------------------------------------------------ cui_checkbox_setcheck() { cui_send "C" "${API_CHECKBOXSETCHECK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get checkbox check status # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Value : Integer (0 or 1) #------------------------------------------------------------------------------ cui_checkbox_getcheck() { cui_send "C" "${API_CHECKBOXGETCHECK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new listbox control: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Window title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- ID : Integer # $8 <-- Set style : Integer (use $CWS_XXX constants) # $9 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_listbox_new() { cui_send "C" "${API_LISTBOXNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a listbox callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_listbox_callback() { cui_send "C" "${API_LISTBOXSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Add string to listbox # Expects: $1 <-- Window : Window Handle # $2 <-- Value : String # Returns: $p2 --> Index : Integer #------------------------------------------------------------------------------ cui_listbox_add() { cui_send "C" "${API_LISTBOXADD}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Delete string from listbox # Expects: $1 <-- Window : Window Handle # $2 <-- Index : Integer # Returns: #------------------------------------------------------------------------------ cui_listbox_delete() { cui_send "C" "${API_LISTBOXDELETE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get string from listbox # Expects: $1 <-- Window : Window Handle # $2 <-- Index : Integer # Returns: $p2 --> Value : String #------------------------------------------------------------------------------ cui_listbox_get() { cui_send "C" "${API_LISTBOXGET}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign data to listbox item # Expects: $1 <-- Window : Window Handle # $2 <-- Index : Integer # $3 <-- Data : Integer # Returns: #------------------------------------------------------------------------------ cui_listbox_adddata() { cui_send "C" "${API_LISTBOXADDDATA}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Read data from listbox item # Expects: $1 <-- Window : Window Handle # $2 <-- Index : Integer # Returns: $p2 --> Data : Integer #------------------------------------------------------------------------------ cui_listbox_getdata() { cui_send "C" "${API_LISTBOXGETDATA}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set current selection # Expects: $1 <-- Window : Window Handle # $2 <-- Index : Integer # Returns: #------------------------------------------------------------------------------ cui_listbox_setsel() { cui_send "C" "${API_LISTBOXSETSEL}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get current selection # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Index : Integer #------------------------------------------------------------------------------ cui_listbox_getsel() { cui_send "C" "${API_LISTBOXGETSEL}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Clear listbox content # Expects: $1 <-- Window : Window Handle # Returns: #------------------------------------------------------------------------------ cui_listbox_clear() { cui_send "C" "${API_LISTBOXCLEAR}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get number of items in listbox # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> NumItems : Integer #------------------------------------------------------------------------------ cui_listbox_getcount() { cui_send "C" "${API_LISTBOXGETCOUNT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Select string in listbox # Expects: $1 <-- Window : Window Handle # $2 <-- String : String to select # Returns: $p2 --> Index : Integer #------------------------------------------------------------------------------ cui_listbox_select() { cui_send "C" "${API_LISTBOXSELECT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new combobox control: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- X : Integer # $3 <-- Y : Integer # $4 <-- W : Integer # $5 <-- H : Integer # $6 <-- ID : Integer # $7 <-- Set style : Integer (use $CWS_XXX constants) # $8 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_combobox_new() { cui_send "C" "${API_COMBOBOXNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a combobox callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_combobox_callback() { cui_send "C" "${API_COMBOBOXSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Add string to combobox # Expects: $1 <-- Window : Window Handle # $2 <-- Value : String # Returns: $p2 --> Index : Integer #------------------------------------------------------------------------------ cui_combobox_add() { cui_send "C" "${API_COMBOBOXADD}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Delete string from combobox # Expects: $1 <-- Window : Window Handle # $2 <-- Index : Integer # Returns: #------------------------------------------------------------------------------ cui_combobox_delete() { cui_send "C" "${API_COMBOBOXDELETE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get string from combobox # Expects: $1 <-- Window : Window Handle # $2 <-- Index : Integer # Returns: $p2 --> Value : String #------------------------------------------------------------------------------ cui_combobox_get() { cui_send "C" "${API_COMBOBOXGET}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign data to combobox item # Expects: $1 <-- Window : Window Handle # $2 <-- Index : Integer # $3 <-- Data : Integer # Returns: #------------------------------------------------------------------------------ cui_combobox_adddata() { cui_send "C" "${API_COMBOBOXADDDATA}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Read data from combobox item # Expects: $1 <-- Window : Window Handle # $2 <-- Index : Integer # Returns: $p2 --> Data : Integer #------------------------------------------------------------------------------ cui_combobox_getdata() { cui_send "C" "${API_COMBOBOXGETDATA}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set current selection # Expects: $1 <-- Window : Window Handle # $2 <-- Index : Integer # Returns: #------------------------------------------------------------------------------ cui_combobox_setsel() { cui_send "C" "${API_COMBOBOXSETSEL}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get current selection # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Index : Integer #------------------------------------------------------------------------------ cui_combobox_getsel() { cui_send "C" "${API_COMBOBOXGETSEL}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Clear combobox content # Expects: $1 <-- Window : Window Handle # Returns: #------------------------------------------------------------------------------ cui_combobox_clear() { cui_send "C" "${API_COMBOBOXCLEAR}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get number of items in combobox # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> NumItems : Integer #------------------------------------------------------------------------------ cui_combobox_getcount() { cui_send "C" "${API_COMBOBOXGETCOUNT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Select string in combobox # Expects: $1 <-- Window : Window Handle # $2 <-- String : String to select # Returns: $p2 --> Index : Integer #------------------------------------------------------------------------------ cui_combobox_select() { cui_send "C" "${API_COMBOBOXSELECT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new progress bar control: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- ID : Integer # $8 <-- Set style : Integer (use $CWS_XXX constants) # $9 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_progress_new() { cui_send "C" "${API_PROGRESSBARNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set bar range # Expects: $1 <-- Window : Window Handle # $2 <-- Range : Integer # Returns: #------------------------------------------------------------------------------ cui_progress_setrange() { cui_send "C" "${API_PROGRESSBARSETRANGE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set bar pos # Expects: $1 <-- Window : Window Handle # $2 <-- Pos : Integer # Returns: #------------------------------------------------------------------------------ cui_progress_setpos() { cui_send "C" "${API_PROGRESSBARSETPOS}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get bar range # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Range : Integer #------------------------------------------------------------------------------ cui_progress_getrange() { cui_send "C" "${API_PROGRESSBARGETRANGE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get bar pos # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Pos : Integer #------------------------------------------------------------------------------ cui_progress_getpos() { cui_send "C" "${API_PROGRESSBARGETPOS}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new textview control: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- ID : Integer # $8 <-- Set style : Integer (use $CWS_XXX constants) # $9 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_textview_new() { cui_send "C" "${API_TEXTVIEWNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a textview callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_textview_callback() { cui_send "C" "${API_TEXTVIEWSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Enable word wrap # Expects: $1 <-- Window : Window Handle # $2 <-- Enable? : Integer (0 or 1) # Returns: #------------------------------------------------------------------------------ cui_textview_wordwrap() { cui_send "C" "${API_TEXTVIEWENABLEWORDWRAP}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Add string to textview # Expects: $1 <-- Window : Window Handle # $2 <-- Value : String # Returns: #------------------------------------------------------------------------------ cui_textview_add() { cui_send "C" "${API_TEXTVIEWADD}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Add string to textview # Expects: $1 <-- Window : Window Handle # $2 <-- Value : String # Returns: #------------------------------------------------------------------------------ cui_textview_clear() { cui_send "C" "${API_TEXTVIEWCLEAR}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Read a file # Expects: $1 <-- Window : Window Handle # $2 <-- Filename : String # Returns: $p2 --> Success : Integer (0=failed, 1=success) #------------------------------------------------------------------------------ cui_textview_read() { cui_send "C" "${API_TEXTVIEWREAD}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # search within textview # Expects: $1 <-- Window : Window Handle # $2 <-- SearchStr : String # $3 <-- WholeWord : Integer (0 or 1) # $4 <-- CaseSense : Integer (0 or 1) # $5 <-- Down : Integer (0 or 1) # Returns: $p2 --> Success : Integer (0=failed, 1=success) #------------------------------------------------------------------------------ cui_textview_search() { cui_send "C" "${API_TEXTVIEWSEARCH}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new listview control: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- Num columns : Integer # $8 <-- ID : Integer # $9 <-- Set style : Integer (use $CWS_XXX constants) # $10 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_listview_new() { cui_send "C" "${API_LISTVIEWNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a listview callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_listview_callback() { cui_send "C" "${API_LISTVIEWSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set listview column titel # Expects: $1 <-- Window : Window Handle # $2 <-- Col-No : Integer # $3 <-- Text : String # Returns: #------------------------------------------------------------------------------ cui_listview_setcoltext() { cui_send "C" "${API_LISTVIEWADDCOLUMN}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set listview column titel # Expects: $1 <-- Window : Window Handle # $2 <-- Col-No : Integer # $3 <-- Alignment : Integer # Returns: #------------------------------------------------------------------------------ cui_listview_settitlealignment() { cui_send "C" "${API_LISTVIEWSETTITLEALIGNMENT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Clear listview data # Expects: $1 <-- Window : Window Handle # Returns: #------------------------------------------------------------------------------ cui_listview_clear() { cui_send "C" "${API_LISTVIEWCLEAR}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Add a new (empty) record to the list view # (must be populated with data using cui_listview_settext) # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Index of new record : Integer #------------------------------------------------------------------------------ cui_listview_add() { cui_send "C" "${API_LISTVIEWADD}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign text data to listview record # Expects: $1 <-- Window : Window Handle # $2 <-- Rec. index : Integer (returned by cui_listview_add) # $3 <-- Col. index : Integer (0 | 1 | ... | cols - 1) # $4 <-- Text : String # Returns: #------------------------------------------------------------------------------ cui_listview_settext() { cui_send "C" "${API_LISTVIEWSETTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get text data assigned listview record # Expects: $1 <-- Window : Window Handle # $2 <-- Rec. index : Integer (returned by cui_listview_add) # $3 <-- Col. index : Integer (0 | 1 | ... | cols - 1) # Returns: $p2 --> Text : String #------------------------------------------------------------------------------ cui_listview_gettext() { cui_send "C" "${API_LISTVIEWGETTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign integer data to listview record # Expects: $1 <-- Window : Window Handle # $2 <-- Rec. index : Integer (returned by cui_listview_add) # $3 <-- Data : Integer # Returns: #------------------------------------------------------------------------------ cui_listview_setdata() { cui_send "C" "${API_LISTVIEWSETDATA}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get integer data from listview record # Expects: $1 <-- Window : Window Handle # $2 <-- Rec. index : Integer (returned by cui_listview_add) # Returns: $p2 --> Data : Integer #------------------------------------------------------------------------------ cui_listview_getdata() { cui_send "C" "${API_LISTVIEWGETDATA}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set current selection in listview control # Expects: $1 <-- Window : Window Handle # $2 <-- Rec. index : Integer (returned by cui_listview_add) # Returns: #------------------------------------------------------------------------------ cui_listview_setsel() { cui_send "C" "${API_LISTVIEWSETSEL}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get current selection of listview control # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Sel. index : Integer (-1 if not selected) #------------------------------------------------------------------------------ cui_listview_getsel() { cui_send "C" "${API_LISTVIEWGETSEL}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get number of records in listview control # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Count : Integer #------------------------------------------------------------------------------ cui_listview_getcount() { cui_send "C" "${API_LISTVIEWGETCOUNT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Update listview visual display after modifying data (!!! function is obsolete !!!) # Expects: $1 <-- Window : Window Handle # Returns: #------------------------------------------------------------------------------ cui_listview_update() { cui_send "C" "${API_LISTVIEWUPDATE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Sort listview column in alphabetic order # Expects: $1 <-- Window : Window Handle # $2 <-- Column : Integer # $3 <-- Dir : 1 = up, 0 = down # Returns: #------------------------------------------------------------------------------ cui_listview_alphasort() { cui_send "C" "${API_LISTVIEWALPHASORT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Sort listview column in numeric order # Expects: $1 <-- Window : Window Handle # $2 <-- Column : Integer # $3 <-- Dir : 1 = up, 0 = down # Returns: #------------------------------------------------------------------------------ cui_listview_numericsort() { cui_send "C" "${API_LISTVIEWNUMERICSORT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set text of a complete row. Fields are separated by '|' letters # Expects: $1 <-- Window : Window Handle # $2 <-- Rec.Index: Integer # $3 <-- Text : String # Returns: #------------------------------------------------------------------------------ cui_listview_setrowtext() { cui_send "C" "${API_LISTVIEWSETROWTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Hilight cell text with window hilight color # Expects: $1 <-- Window : Window Handle # $2 <-- Rec.Index: Integer # $3 <-- Col.Index: Integer # $4 <-- Hilight : Integer (Boolean 0/1) # Returns: #------------------------------------------------------------------------------ cui_listview_hilight() { cui_send "C" "${API_LISTVIEWHILIGHT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new terminal control: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- ID : Integer # $8 <-- Set style : Integer (use $CWS_XXX constants) # $9 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_terminal_new() { cui_send "C" "${API_TERMINALNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a terminal callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_terminal_callback() { cui_send "C" "${API_TERMINALSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Write text into the terminal window # Expects: $1 <-- Window : Window Handle # $2 <-- Text : String # Returns: #------------------------------------------------------------------------------ cui_terminal_write() { cui_send "C" "${API_TERMINALWRITE}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Run a command within the terminal window # Expects: $1 <-- Window : Window Handle # $2 <-- Text : String # Returns: $p2 --> Success : Integer (0 or 1 !not the exit code of the process!) #------------------------------------------------------------------------------ cui_terminal_run() { cui_send "C" "${API_TERMINALRUN}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Pipe text data to the running co process # Expects: $1 <-- Window : Window Handle # $2 <-- Text : String # Returns: #------------------------------------------------------------------------------ cui_terminal_pipe() { cui_send "C" "${API_TERMINALPIPEDATA}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new menu control: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- ID : Integer # $8 <-- Set style : Integer (use $CWS_XXX constants) # $9 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_menu_new() { cui_send "C" "${API_MENUNEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a menu callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_menu_callback() { cui_send "C" "${API_MENUSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Add a menu item # Expects: $1 <-- Window : Window Handle # $2 <-- Text : String # $3 <-- Id : Item id # Returns: #------------------------------------------------------------------------------ cui_menu_additem() { cui_send "C" "${API_MENUADDITEM}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Add a menu separator # Expects: $1 <-- Window : Window Handle # Returns: #------------------------------------------------------------------------------ cui_menu_addseparator() { cui_send "C" "${API_MENUADDSEPARATOR}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Select menu item # Expects: $1 <-- Window : Window Handle # $2 <-- Id : Integer (item id) # Returns: #------------------------------------------------------------------------------ cui_menu_selitem() { cui_send "C" "${API_MENUSELECTITEM}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get selected menu item # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> ItemId : Integer #------------------------------------------------------------------------------ cui_menu_getselitem() { cui_send "C" "${API_MENUGETSELITEM}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Clear menu # Expects: $1 <-- Window : Window Handle # Returns: #------------------------------------------------------------------------------ cui_menu_clear() { cui_send "C" "${API_MENUCLEAR}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Make new memo: # Expects: $1 <-- Parent Window : Window Handle # $2 <-- Window title : String # $3 <-- X : Integer # $4 <-- Y : Integer # $5 <-- W : Integer # $6 <-- H : Integer # $7 <-- ID : Integer # $8 <-- Set style : Integer (use $CWS_XXX constants) # $9 <-- Clear style : Integer (use $CWS_XXX constants) # Returns: $p2 --> New Window : Window Handle #------------------------------------------------------------------------------ cui_memo_new() { cui_send "C" "${API_MEMONEW}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Assign a memo callback # Expects: $1 <-- Window : Window Handle # $2 <-- Hook : Integer (use $HOOK_XXX constants) # $3 <-- Target : Window Handle # $4 <-- Proc : String (name of shell function) # Returns: #------------------------------------------------------------------------------ cui_memo_callback() { cui_send "C" "${API_MEMOSETCALLBACK}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set memo text # Expects: $1 <-- Window : Window Handle # $2 <-- Text : String # Returns: #------------------------------------------------------------------------------ cui_memo_settext() { cui_send "C" "${API_MEMOSETTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Get memo text # Expects: $1 <-- Window : Window Handle # Returns: $p2 --> Text : String #------------------------------------------------------------------------------ cui_memo_gettext() { cui_send "C" "${API_MEMOGETTEXT}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Set memo wrap columns # Expects: $1 <-- Window : Window Handle # $2 <-- Columns: Integer # Returns: #------------------------------------------------------------------------------ cui_memo_setwrapcolumns() { cui_send "C" "${API_MEMOSETWRAPCOLUMNS}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # util functions #------------------------------------------------------------------------------ #------------------------------------------------------------------------------ # Read XML tag # Expects: $1 <-- Filename : String # $2 <-- Search Spec : String (something like "tag:subtag:subsubtag" # Returns: $p2 --> Data : String #------------------------------------------------------------------------------ xml_read_tag() { cui_send "C" "${API_XMLREADTAG}" "$@" cui_wait_ack return $? } #------------------------------------------------------------------------------ # Load addon module # Expects: $1 <-- Filename : String (library with full pathname) # Returns: $p2 --> ModuleOffset : String (0 if error, > 10000 if success) #------------------------------------------------------------------------------ cui_load_addon() { cui_send "C" "${API_LOADADDON}" "$@" cui_wait_ack return $? }