From 773013b8e45a6916a74ea64152e51fb6cb951920 Mon Sep 17 00:00:00 2001 From: Pascal Rigaux Date: Sun, 14 Nov 1999 23:09:15 +0000 Subject: no_comment --- perl-install/Newt/.cvsignore | 6 + perl-install/Newt/Av_CharPtrPtr.c | 99 +++++++ perl-install/Newt/Av_CharPtrPtr.h | 4 + perl-install/Newt/Makefile.PL | 13 + perl-install/Newt/Newt.pm | 16 ++ perl-install/Newt/Newt.xs | 546 ++++++++++++++++++++++++++++++++++++++ perl-install/Newt/typemap | 25 ++ 7 files changed, 709 insertions(+) create mode 100644 perl-install/Newt/.cvsignore create mode 100644 perl-install/Newt/Av_CharPtrPtr.c create mode 100644 perl-install/Newt/Av_CharPtrPtr.h create mode 100644 perl-install/Newt/Makefile.PL create mode 100644 perl-install/Newt/Newt.pm create mode 100644 perl-install/Newt/Newt.xs create mode 100644 perl-install/Newt/typemap (limited to 'perl-install/Newt') diff --git a/perl-install/Newt/.cvsignore b/perl-install/Newt/.cvsignore new file mode 100644 index 000000000..c296b7faf --- /dev/null +++ b/perl-install/Newt/.cvsignore @@ -0,0 +1,6 @@ +Newt.bs +Newt.c +pm_to_blib +blib +Makefile +Makefile_c diff --git a/perl-install/Newt/Av_CharPtrPtr.c b/perl-install/Newt/Av_CharPtrPtr.c new file mode 100644 index 000000000..d108ef5d0 --- /dev/null +++ b/perl-install/Newt/Av_CharPtrPtr.c @@ -0,0 +1,99 @@ +#ifdef __cplusplus +extern "C" { +#endif +#include "EXTERN.h" +#include "perl.h" +#include "XSUB.h" +#include "Av_CharPtrPtr.h" /* XS_*_charPtrPtr() */ +#ifdef __cplusplus +} +#endif + + +/* Used by the INPUT typemap for char**. + * Will convert a Perl AV* (containing strings) to a C char**. + */ +char ** +XS_unpack_charPtrPtr( rv ) +SV *rv; +{ + AV *av; + SV **ssv; + char **s; + int avlen; + int x; + + if( SvROK( rv ) && (SvTYPE(SvRV(rv)) == SVt_PVAV) ) + av = (AV*)SvRV(rv); + else { + warn("XS_unpack_charPtrPtr: rv was not an AV ref"); + return( (char**)NULL ); + } + + /* is it empty? */ + avlen = av_len(av); + if( avlen < 0 ){ + warn("XS_unpack_charPtrPtr: array was empty"); + return( (char**)NULL ); + } + + /* av_len+2 == number of strings, plus 1 for an end-of-array sentinel. + */ + s = (char **)safemalloc( sizeof(char*) * (avlen + 2) ); + if( s == NULL ){ + warn("XS_unpack_charPtrPtr: unable to malloc char**"); + return( (char**)NULL ); + } + for( x = 0; x <= avlen; ++x ){ + ssv = av_fetch( av, x, 0 ); + if( ssv != NULL ){ + if( SvPOK( *ssv ) ){ + s[x] = (char *)safemalloc( SvCUR(*ssv) + 1 ); + if( s[x] == NULL ) + warn("XS_unpack_charPtrPtr: unable to malloc char*"); + else + strcpy( s[x], SvPV( *ssv, na ) ); + } + else + warn("XS_unpack_charPtrPtr: array elem %d was not a string.", x ); + } + else + s[x] = (char*)NULL; + } + s[x] = (char*)NULL; /* sentinel */ + return( s ); +} + +/* Used by the OUTPUT typemap for char**. + * Will convert a C char** to a Perl AV*. + */ +void +XS_pack_charPtrPtr( st, s ) +SV *st; +char **s; +{ + AV *av = newAV(); + SV *sv; + char **c; + + for( c = s; *c != NULL; ++c ){ + sv = newSVpv( *c, 0 ); + av_push( av, sv ); + } + sv = newSVrv( st, NULL ); /* upgrade stack SV to an RV */ + SvREFCNT_dec( sv ); /* discard */ + SvRV( st ) = (SV*)av; /* make stack RV point at our AV */ +} + + +/* cleanup the temporary char** from XS_unpack_charPtrPtr */ +void +XS_release_charPtrPtr(s) +char **s; +{ + char **c; + for( c = s; *c != NULL; ++c ) + safefree( *c ); + safefree( s ); +} + diff --git a/perl-install/Newt/Av_CharPtrPtr.h b/perl-install/Newt/Av_CharPtrPtr.h new file mode 100644 index 000000000..765f1a731 --- /dev/null +++ b/perl-install/Newt/Av_CharPtrPtr.h @@ -0,0 +1,4 @@ +char ** XS_unpack_charPtrPtr _(( SV *rv )); +void XS_pack_charPtrPtr _(( SV *st, char **s )); +void XS_release_charPtrPtr _(( char **s )); + diff --git a/perl-install/Newt/Makefile.PL b/perl-install/Newt/Makefile.PL new file mode 100644 index 000000000..6378a8f31 --- /dev/null +++ b/perl-install/Newt/Makefile.PL @@ -0,0 +1,13 @@ +use ExtUtils::MakeMaker; +# See lib/ExtUtils/MakeMaker.pm for details of how to influence +# the contents of the Makefile that is written. + +WriteMakefile( + 'NAME' => 'Newt', + 'OBJECT' => 'Av_CharPtrPtr.o Newt.o', + 'MAKEFILE' => 'Makefile_c', + 'OPTIMIZE' => '-Os', + 'VERSION_FROM' => 'Newt.pm', # finds $VERSION + 'LIBS' => ['-lnewt -lslang'], + 'DEFINE' => '', # e.g., '-DHAVE_SOMETHING' +); diff --git a/perl-install/Newt/Newt.pm b/perl-install/Newt/Newt.pm new file mode 100644 index 000000000..80dbaf54f --- /dev/null +++ b/perl-install/Newt/Newt.pm @@ -0,0 +1,16 @@ +package Newt; + +use strict; +use vars qw($VERSION @ISA); +use DynaLoader; + +use vars qw($VERSION @ISA); +@ISA = qw(DynaLoader); +$VERSION = '0.01'; +bootstrap Newt $VERSION; + +package Newt::Component; +package Newt::Grid; + + +1; diff --git a/perl-install/Newt/Newt.xs b/perl-install/Newt/Newt.xs new file mode 100644 index 000000000..e60583de1 --- /dev/null +++ b/perl-install/Newt/Newt.xs @@ -0,0 +1,546 @@ +#include "EXTERN.h" +#include "perl.h" +#include "XSUB.h" +#include + +static void suspend() { + newtSuspend(); + raise(SIGTSTP); + newtResume(); +} + +typedef newtComponent Newt__Component; +typedef newtGrid Newt__Grid; + + +MODULE = Newt PACKAGE = Newt PREFIX = newt + +void +DESTROY() + CODE: + { + newtFinished(); + } + +void +changeColors() + CODE: +{ +const struct newtColors colors = { + "cyan", "black", /* root fg, bg */ + "black", "blue", /* border fg, bg */ + "white", "blue", /* window fg, bg */ + "white", "black", /* shadow fg, bg */ + "white", "blue", /* title fg, bg */ + "yellow", "cyan", /* button fg, bg */ + "white", "cyan", /* active button fg, bg */ + "yellow", "blue", /* checkbox fg, bg */ + "blue", "brown", /* active checkbox fg, bg */ + "yellow", "blue", /* entry box fg, bg */ + "white", "blue", /* label fg, bg */ + "black", "cyan", /* listbox fg, bg */ + "yellow", "cyan", /* active listbox fg, bg */ + "white", "blue", /* textbox fg, bg */ + "cyan", "black", /* active textbox fg, bg */ + "white", "blue", /* help line */ + "yellow", "blue", /* root text */ + "blue", /* scale full */ + "red", /* scale empty */ + "blue", "cyan", /* disabled entry fg, bg */ + "white", "blue", /* compact button fg, bg */ + "yellow", "red", /* active & sel listbox */ + "black", "brown" /* selected listbox */ +}; + newtSetColors(colors); +} + +int +newtInit() + +int +newtFinished() + +void +newtCls() + +int +newtCenteredWindow(width,height,title) + int width; + int height; + const char * title; + +void +newtPopWindow() + +void +newtRefresh() + +void +newtPushHelpLine(text) + const char * text; + +void +newtDrawRootText(row,col,text) + int row; + int col; + const char * text; + +void +newtGetScreenSize() + PPCODE: +{ + int cols, rows; + newtGetScreenSize(&cols, &rows); + PUSHs(sv_2mortal(newSViv(cols))); + PUSHs(sv_2mortal(newSViv(rows))); +} + +void +newtSetSuspendCallback() + CODE: + { + newtSetSuspendCallback(suspend, NULL); + } + + +void +newtWinMessage(title,buttonText,text) + char * title; + char * buttonText; + char * text; + +int +newtWinChoice(title,button1,button2,text) + char * title; + char * button1; + char * button2; + char * text; + +int +newtWinTernary(title,button1,button2,button3,message) + char * title; + char * button1; + char * button2; + char * button3; + char * message; + +void +newtWinMenu(title,text,suggestedWidth,flexDown,flexUp,maxListHeight,list,def,buttons, ...) + char * title; + char * text; + int suggestedWidth; + int flexDown; + int flexUp; + int maxListHeight; + char **list; + int def; + char *buttons; + PPCODE: + { + int button; +#define nb 8 +#define a(i) SvPV(ST(i + nb),PL_na) + button = newtWinMenu(title, text, suggestedWidth, flexDown, flexUp, maxListHeight, list, &def, + items > nb + 0 ? a( 0) : NULL, + items > nb + 1 ? a( 1) : NULL, + items > nb + 2 ? a( 2) : NULL, + items > nb + 3 ? a( 3) : NULL, + items > nb + 4 ? a( 4) : NULL, + items > nb + 5 ? a( 5) : NULL, + items > nb + 6 ? a( 6) : NULL, + items > nb + 7 ? a( 7) : NULL, + items > nb + 8 ? a( 8) : NULL, + items > nb + 9 ? a( 9) : NULL, + items > nb + 10 ? a(10) : NULL, + NULL); +#undef a + EXTEND(SP, 2); + PUSHs(sv_2mortal(newSViv(button))); + PUSHs(sv_2mortal(newSViv(def))); + } + +MODULE = Newt PACKAGE = Newt::Component PREFIX = newt + +Newt::Component +newtCompactButton(left,top,text) + int left; + int top; + const char * text; + +Newt::Component +newtButton(left,top,text) + int left; + int top; + const char * text; + +Newt::Component +newtCheckbox(left,top,text,defValue,seq,result) + int left; + int top; + const char * text; + char *defValue; + const char * seq; + int *result; + CODE: + RETVAL = newtCheckbox(left, top, text, defValue[0], seq, (char*)result); + OUTPUT: + RETVAL + +int +newtCheckboxGetValue(co) + Newt::Component co; + +void +newtCheckboxSetValue(co, value) + Newt::Component co; + char *value; + CODE: + newtCheckboxSetValue(co, value[0]); + +Newt::Component +newtLabel(left,top,text) + int left; + int top; + const char * text; + +void +newtLabelSetText(co,text) + Newt::Component co; + const char * text; + +Newt::Component +newtVerticalScrollbar(left,top,height,normalColorset,thumbColorset) + int left; + int top; + int height; + int normalColorset; + int thumbColorset; + +void +newtScrollbarSet(co,where,total) + Newt::Component co; + int where; + int total; + +Newt::Component +newtListbox(left,top,height,flags) + int left; + int top; + int height; + int flags; + +void * +newtListboxGetCurrent(co) + Newt::Component co; + +void +newtListboxSetCurrent(co,num) + Newt::Component co; + int num; + +void +newtListboxSetCurrentByKey(co,key) + Newt::Component co; + void * key; + +void +newtListboxSetText(co,num,text) + Newt::Component co; + int num; + const char * text; + +void +newtListboxSetEntry(co,num,text) + Newt::Component co; + int num; + const char * text; + +void +newtListboxSetWidth(co,width) + Newt::Component co; + int width; + +# return the data passed to AddEntry +void +newtListboxSetData(co,num,data) + Newt::Component co; + int num; + void * data; + +int +newtListboxAddEntry(co,text,data) + Newt::Component co; + const char * text; + const void * data; + +# Send the key to insert after, or NULL to insert at the top +int +newtListboxInsertEntry(co,text,data,key) + Newt::Component co; + const char * text; + const void * data; + void * key; + +int +newtListboxDeleteEntry(co,data) + Newt::Component co; + void * data; + +# removes all entries from listbox +void +newtListboxClear(co) + Newt::Component co; + +void +newtListboxGetEntry(co,num,text,data) + Newt::Component co; + int num; + char * text; + void * data; + PPCODE: + { + newtListboxGetEntry(co, num, &text, data); + } + +# Returns an array of data pointers from items, last element is NULL +void * +newtListboxGetSelection(co,numitems) + Newt::Component co; + int *numitems; + +void +newtListboxClearSelection(co) + Newt::Component co; + +void +newtListboxSelectItem(co,key,sense) + Newt::Component co; + void *key + enum newtFlagsSense sense; + +Newt::Component +newtTextboxReflowed(left,top,text,width,flexDown,flexUp,flags) + int left; + int top; + char * text; + int width; + int flexDown; + int flexUp; + int flags; + +Newt::Component +newtTextbox(left,top,width,height,flags) + int left; + int top; + int width; + int height; + int flags; + +void +newtTextboxSetText(co,text) + Newt::Component co; + const char * text; + +void +newtTextboxSetHeight(co,height) + Newt::Component co; + int height; + +int +newtTextboxGetNumLines(co) + Newt::Component co; + +char * +newtReflowText(text,width,flexDown,flexUp,actualWidth,actualHeight) + char * text; + int width; + int flexDown; + int flexUp; + int * actualWidth; + int * actualHeight; + +Newt::Component +newtForm(vertBar,help,flags) + Newt::Component vertBar; + const char * help; + int flags; + +void +newtFormSetSize(co) + Newt::Component co; + +Newt::Component +newtFormGetCurrent(co) + Newt::Component co; + +void +newtFormSetBackground(co,color) + Newt::Component co; + int color; + +void +newtFormSetCurrent(co,subco) + Newt::Component co; + Newt::Component subco; + +void +newtFormAddComponent(form,co) + Newt::Component form; + Newt::Component co; + +void +newtFormSetHeight(co,height) + Newt::Component co; + int height; + +void +newtFormSetWidth(co,width) + Newt::Component co; + int width; + +Newt::Component +newtRunForm(form) + Newt::Component form; + +void +newtDrawForm(form) + Newt::Component form; + +Newt::Component +newtEntry(left,top,initialValue,width,flag) + int left; + int top; + const char * initialValue; + int width; + int flag; + CODE: + { + char *result; + RETVAL = newtEntry(left,top,initialValue,width,&result,flag); + } + OUTPUT: + RETVAL + +void +newtEntrySet(co,value,cursorAtEnd) + Newt::Component co; + const char * value; + int cursorAtEnd; + +char * +newtEntryGetValue(co) + Newt::Component co; + +void +newtFormDestroy(form) + Newt::Component form; + +MODULE = Newt PACKAGE = Newt::Grid PREFIX = newt + +Newt::Grid +newtCreateGrid(cols,rows) + int cols; + int rows; + +Newt::Grid +HCloseStacked(first, ...) + Newt::Component first; + CODE: + { + int i; +#define a(i) (newtComponent)SvIV((SV*)SvRV( ST(i) )) + RETVAL = + newtGridHCloseStacked( + items > 0 ? 1 : 0, items > 0 ? a( 0) : NULL, + items > 1 ? 1 : 0, items > 1 ? a( 1) : NULL, + items > 2 ? 1 : 0, items > 2 ? a( 2) : NULL, + items > 3 ? 1 : 0, items > 3 ? a( 3) : NULL, + items > 4 ? 1 : 0, items > 4 ? a( 4) : NULL, + items > 5 ? 1 : 0, items > 5 ? a( 5) : NULL, + items > 6 ? 1 : 0, items > 6 ? a( 6) : NULL, + items > 7 ? 1 : 0, items > 7 ? a( 7) : NULL, + items > 8 ? 1 : 0, items > 8 ? a( 8) : NULL, + items > 9 ? 1 : 0, items > 9 ? a( 9) : NULL, + items > 10 ? 1 : 0, items > 10 ? a(10) : NULL, + NULL); +#undef a + } +OUTPUT: +RETVAL + + +Newt::Grid +newtGridBasicWindow(text,middle,buttons) + Newt::Component text; + Newt::Grid middle; + Newt::Grid buttons; + + +Newt::Grid +newtGridSimpleWindow(text,middle,buttons) + Newt::Component text; + Newt::Component middle; + Newt::Grid buttons; + +void +newtGridSetField(grid,col,row,type,val,padLeft,padTop,padRight,padBottom,anchor,flags) + Newt::Grid grid; + int col; + int row; + enum newtGridElement type; + void * val; + int padLeft; + int padTop; + int padRight; + int padBottom; + int anchor; + int flags; + + +void +newtGridFree(grid,recurse) + Newt::Grid grid; + int recurse; + +void +newtGridGetSize(grid,width,height) + Newt::Grid grid; + int * width; + int * height; + +void +newtGridWrappedWindow(grid,title) + Newt::Grid grid; + char * title; + +void +newtGridAddComponentsToForm(grid,form,recurse) + Newt::Grid grid; + Newt::Component form; + int recurse; + +Newt::Grid +newtButtonBar(button1, ...) + char * button1; + PPCODE: + { + static newtComponent p[11]; + int i; + EXTEND(SP, items + 1); +#define a(i) (char *)SvPV(ST(i),PL_na) + PUSHs(sv_setref_pv(sv_newmortal(), "Newt::Grid", + newtButtonBar(items > 0 ? a( 0) : NULL, items > 0 ? &p[ 0] : NULL, + items > 1 ? a( 1) : NULL, items > 1 ? &p[ 1] : NULL, + items > 2 ? a( 2) : NULL, items > 2 ? &p[ 2] : NULL, + items > 3 ? a( 3) : NULL, items > 3 ? &p[ 3] : NULL, + items > 4 ? a( 4) : NULL, items > 4 ? &p[ 4] : NULL, + items > 5 ? a( 5) : NULL, items > 5 ? &p[ 5] : NULL, + items > 6 ? a( 6) : NULL, items > 6 ? &p[ 6] : NULL, + items > 7 ? a( 7) : NULL, items > 7 ? &p[ 7] : NULL, + items > 8 ? a( 8) : NULL, items > 8 ? &p[ 8] : NULL, + items > 9 ? a( 9) : NULL, items > 9 ? &p[ 9] : NULL, + items > 10 ? a(10) : NULL, items > 10 ? &p[10] : NULL, + NULL))); +#undef a + for (i = 0; i < items; i++) PUSHs(sv_setref_pv(sv_newmortal(), "Newt::Component", p[i])); + } diff --git a/perl-install/Newt/typemap b/perl-install/Newt/typemap new file mode 100644 index 000000000..5aaa2f668 --- /dev/null +++ b/perl-install/Newt/typemap @@ -0,0 +1,25 @@ +TYPEMAP + +const char * T_PV +const void * T_PV +int * T_PV +void ** T_PACKED + +enum newtFlagsSense T_IV +enum newtGridElement T_IV +SV ** T_SV + +Newt::Component NewtComponent +Newt::Grid NewtGrid + +INPUT +NewtComponent + $var = ($type) SvIV((SV*)SvRV($arg)) +NewtGrid + $var = ($type) SvIV((SV*)SvRV($arg)) + +OUTPUT +NewtComponent + sv_setref_pv($arg, "Newt::Component", (void*) $var); +NewtGrid + sv_setref_pv($arg, "Newt::Grid", (void*) $var); -- cgit v1.2.1