├── MAKE ├── resources │ ├── palmos_info.def │ ├── 15.bmp │ ├── 22.bmp │ ├── 30.bmp │ ├── 44.bmp │ └── palmos_resources.rcp ├── HOW_TO_MAKE.txt ├── MAKE_PALMOS ├── MAKE_WIN32_GDI ├── MAKE_WIN64_GDI ├── MAKE_LINUX_X86_CONSOLE ├── MAKE_WIN32_OPENGL ├── MAKE_WIN64_OPENGL ├── MAKE_LINUX_X86_64_CONSOLE ├── MAKE_LINUX_X86_X11 ├── MAKE_LINUX_X86_64_X11 ├── MAKE_LINUX_X86_OPENGL ├── MAKE_LINUX_X86_64_OPENGL ├── palmos │ ├── armscript.ld │ ├── palm_functions.h │ ├── DebugMgr.h │ ├── PalmTypes.h │ └── arm_starter.cpp └── HOW_TO_MAKE_PALMOS.txt ├── BIN ├── font.jpg ├── psytexx_config.ini ├── background.jpg ├── background2.jpg ├── background3.jpg └── background_palette.jpg ├── DOCS ├── simple.xm ├── effect_0.xm ├── effect_1.xm ├── effect_2.xm ├── effect_3.xm ├── effect_4.xm ├── effect_8.xm ├── effect_A.xm ├── effect_F.xm ├── volumes.xm ├── multi_effects.xm ├── multichannel.xm ├── manual │ ├── manual1.png │ ├── manual2.png │ ├── manual3.png │ └── index.htm ├── psytexx2_alpha_0.6_2024_palm.jpg ├── psytexx2_alpha_0.6_2024_x11.jpg └── XM │ └── xi.txt ├── MUSIC ├── test.xm ├── test2.xm ├── COOLER.xm └── music_license.txt ├── .gitignore ├── time ├── time.h └── time.cpp ├── log ├── log.h └── log.cpp ├── psytexx ├── win_psychannels.h ├── win_popup.h ├── win_psyconfig.h ├── win_psypatterntab.h ├── win_psysmpview.h ├── win_dialog.h ├── win_psynet.h ├── win_psysamples.h ├── win_psyinsteditor.h ├── win_button.h ├── win_psymenu.h ├── win_psysmpeditor.h ├── win_psypattern.h ├── win_main.h ├── win_psyplaylist.h ├── win_text.h ├── win_scrollbar.h ├── win_list.h ├── win_files.h ├── main.cpp ├── win_psyconfig.cpp ├── win_button.cpp ├── win_popup.cpp ├── win_psytable.h ├── win_psypatterntab.cpp ├── win_psypattern.cpp └── win_dialog.cpp ├── sound ├── sound.h └── sound_player.cpp ├── tiny_jpg └── jpg.h ├── LICENSE ├── psynth ├── psynth_net.h ├── psynth_code_template.cpp ├── psynths.cpp └── psynth.h ├── core └── core.h ├── wm ├── wm_opengl.h ├── wm_directx.h ├── wm_palmos.h ├── wm.h └── wm_font.h ├── memory └── memory.h ├── README.md ├── xm ├── xm_song.cpp ├── xm_sample.cpp ├── xm_pattern.cpp ├── xm_channels.cpp └── xm_tables.cpp ├── changelog.txt └── file └── file.h /MAKE/resources/palmos_info.def: -------------------------------------------------------------------------------- 1 | application { "PsyTexx2" ZULU } 2 | -------------------------------------------------------------------------------- /BIN/font.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/BIN/font.jpg -------------------------------------------------------------------------------- /BIN/psytexx_config.ini: -------------------------------------------------------------------------------- 1 | //width 800 2 | //height 600 3 | //buffer 1024 4 | -------------------------------------------------------------------------------- /DOCS/simple.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/simple.xm -------------------------------------------------------------------------------- /MUSIC/test.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/MUSIC/test.xm -------------------------------------------------------------------------------- /MUSIC/test2.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/MUSIC/test2.xm -------------------------------------------------------------------------------- /DOCS/effect_0.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/effect_0.xm -------------------------------------------------------------------------------- /DOCS/effect_1.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/effect_1.xm -------------------------------------------------------------------------------- /DOCS/effect_2.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/effect_2.xm -------------------------------------------------------------------------------- /DOCS/effect_3.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/effect_3.xm -------------------------------------------------------------------------------- /DOCS/effect_4.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/effect_4.xm -------------------------------------------------------------------------------- /DOCS/effect_8.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/effect_8.xm -------------------------------------------------------------------------------- /DOCS/effect_A.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/effect_A.xm -------------------------------------------------------------------------------- /DOCS/effect_F.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/effect_F.xm -------------------------------------------------------------------------------- /DOCS/volumes.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/volumes.xm -------------------------------------------------------------------------------- /MUSIC/COOLER.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/MUSIC/COOLER.xm -------------------------------------------------------------------------------- /BIN/background.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/BIN/background.jpg -------------------------------------------------------------------------------- /BIN/background2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/BIN/background2.jpg -------------------------------------------------------------------------------- /BIN/background3.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/BIN/background3.jpg -------------------------------------------------------------------------------- /DOCS/multi_effects.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/multi_effects.xm -------------------------------------------------------------------------------- /DOCS/multichannel.xm: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/multichannel.xm -------------------------------------------------------------------------------- /MAKE/resources/15.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/MAKE/resources/15.bmp -------------------------------------------------------------------------------- /MAKE/resources/22.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/MAKE/resources/22.bmp -------------------------------------------------------------------------------- /MAKE/resources/30.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/MAKE/resources/30.bmp -------------------------------------------------------------------------------- /MAKE/resources/44.bmp: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/MAKE/resources/44.bmp -------------------------------------------------------------------------------- /DOCS/manual/manual1.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/manual/manual1.png -------------------------------------------------------------------------------- /DOCS/manual/manual2.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/manual/manual2.png -------------------------------------------------------------------------------- /DOCS/manual/manual3.png: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/manual/manual3.png -------------------------------------------------------------------------------- /BIN/background_palette.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/BIN/background_palette.jpg -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | pack 2 | /BIN/.prop* 3 | /BIN/log.txt 4 | /BIN/psytexx_linux* 5 | /BIN/psytexx_palmos* 6 | /BIN/psytexx_win* 7 | -------------------------------------------------------------------------------- /DOCS/psytexx2_alpha_0.6_2024_palm.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/psytexx2_alpha_0.6_2024_palm.jpg -------------------------------------------------------------------------------- /DOCS/psytexx2_alpha_0.6_2024_x11.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/pixicoder/PsyTexx2/HEAD/DOCS/psytexx2_alpha_0.6_2024_x11.jpg -------------------------------------------------------------------------------- /MUSIC/music_license.txt: -------------------------------------------------------------------------------- 1 | All music in this folder is licensed under CC BY 4.0: https://creativecommons.org/licenses/by/4.0/ 2 | 3 | (c) 1999-2007 Alexander Zolotov 4 | WarmPlace.ru 5 | -------------------------------------------------------------------------------- /MAKE/HOW_TO_MAKE.txt: -------------------------------------------------------------------------------- 1 | Execute one of the MAKE_* bash scripts in Linux/macOS Terminal. 2 | If compilation is successful, you will find the executable file in the ../BIN folder. 3 | 4 | Requirements: 5 | make, gcc, MinGW (Windows), SDL2 lib 6 | -------------------------------------------------------------------------------- /MAKE/MAKE_PALMOS: -------------------------------------------------------------------------------- 1 | set -e 2 | 3 | MAKE_CFLAGS="-O3 -DCOLOR8BITS -DNOPSYNTH -DSLOWMODE" 4 | MAKE_LDFLAGS="-O3" 5 | MAKE_LIBS="" 6 | make palm CFLAGS="$MAKE_CFLAGS" LDFLAGS="$MAKE_LDFLAGS" LIBS="$MAKE_LIBS" 7 | mv -f psytexx.prc ../BIN/psytexx_palmos.prc -------------------------------------------------------------------------------- /MAKE/MAKE_WIN32_GDI: -------------------------------------------------------------------------------- 1 | set -e 2 | 3 | MAKE_CFLAGS="-O3 -DGDI -DCOLOR32BITS" 4 | MAKE_LDFLAGS="-O3" 5 | MAKE_LIBS="-lgdi32" 6 | make win32 -j16 CFLAGS="$MAKE_CFLAGS" LDFLAGS="$MAKE_LDFLAGS" LIBS="$MAKE_LIBS" 7 | mv -f psytexx.exe ../BIN/psytexx_win32_gdi.exe -------------------------------------------------------------------------------- /MAKE/MAKE_WIN64_GDI: -------------------------------------------------------------------------------- 1 | set -e 2 | 3 | MAKE_CFLAGS="-O3 -DGDI -DCOLOR32BITS" 4 | MAKE_LDFLAGS="-O3" 5 | MAKE_LIBS="-lgdi32" 6 | make win64 -j16 CFLAGS="$MAKE_CFLAGS" LDFLAGS="$MAKE_LDFLAGS" LIBS="$MAKE_LIBS" 7 | mv -f psytexx.exe ../BIN/psytexx_win64_gdi.exe -------------------------------------------------------------------------------- /MAKE/MAKE_LINUX_X86_CONSOLE: -------------------------------------------------------------------------------- 1 | set -e 2 | 3 | MAKE_CFLAGS="-O3 -m32 -DCOLOR32BITS -DTEXTMODE" 4 | MAKE_LDFLAGS="-O3 -m32" 5 | MAKE_LIBS="-lgpm" 6 | make linux -j16 CFLAGS="$MAKE_CFLAGS" LDFLAGS="$MAKE_LDFLAGS" LIBS="$MAKE_LIBS" 7 | mv -f psytexx ../BIN/psytexx_linux_x86_console -------------------------------------------------------------------------------- /MAKE/MAKE_WIN32_OPENGL: -------------------------------------------------------------------------------- 1 | set -e 2 | 3 | MAKE_CFLAGS="-O3 -DOPENGL -DCOLOR32BITS" 4 | MAKE_LDFLAGS="-O3" 5 | MAKE_LIBS="-lgdi32 -lopengl32" 6 | make win32 -j16 CFLAGS="$MAKE_CFLAGS" LDFLAGS="$MAKE_LDFLAGS" LIBS="$MAKE_LIBS" 7 | mv -f psytexx.exe ../BIN/psytexx_win32_opengl.exe -------------------------------------------------------------------------------- /MAKE/MAKE_WIN64_OPENGL: -------------------------------------------------------------------------------- 1 | set -e 2 | 3 | MAKE_CFLAGS="-O3 -DOPENGL -DCOLOR32BITS" 4 | MAKE_LDFLAGS="-O3" 5 | MAKE_LIBS="-lgdi32 -lopengl32" 6 | make win64 -j16 CFLAGS="$MAKE_CFLAGS" LDFLAGS="$MAKE_LDFLAGS" LIBS="$MAKE_LIBS" 7 | mv -f psytexx.exe ../BIN/psytexx_win64_opengl.exe -------------------------------------------------------------------------------- /MAKE/MAKE_LINUX_X86_64_CONSOLE: -------------------------------------------------------------------------------- 1 | set -e 2 | 3 | MAKE_CFLAGS="-O3 -m64 -DCOLOR32BITS -DTEXTMODE" 4 | MAKE_LDFLAGS="-O3 -m64" 5 | MAKE_LIBS="-lgpm" 6 | make linux -j16 CFLAGS="$MAKE_CFLAGS" LDFLAGS="$MAKE_LDFLAGS" LIBS="$MAKE_LIBS" 7 | mv -f psytexx ../BIN/psytexx_linux_x86_64_console -------------------------------------------------------------------------------- /MAKE/MAKE_LINUX_X86_X11: -------------------------------------------------------------------------------- 1 | set -e 2 | 3 | MAKE_CFLAGS="-O3 -m32 -DX11 -DCOLOR32BITS" 4 | MAKE_LDFLAGS="-O3 -m32" 5 | MAKE_LIBS="-L/usr/X11R6/lib -lX11" 6 | make linux -j16 CFLAGS="$MAKE_CFLAGS" LDFLAGS="$MAKE_LDFLAGS" LIBS="$MAKE_LIBS" 7 | mv -f psytexx ../BIN/psytexx_linux_x86_x11 -------------------------------------------------------------------------------- /time/time.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | 5 | uint time_hours( void ); 6 | uint time_minutes( void ); 7 | uint time_seconds( void ); 8 | uint time_ticks_per_second( void ); 9 | uint time_ticks( void ); 10 | void time_sleep( int milliseconds ); 11 | -------------------------------------------------------------------------------- /MAKE/MAKE_LINUX_X86_64_X11: -------------------------------------------------------------------------------- 1 | set -e 2 | 3 | MAKE_CFLAGS="-O3 -m64 -DX11 -DCOLOR32BITS" 4 | MAKE_LDFLAGS="-O3 -m64" 5 | MAKE_LIBS="-L/usr/X11R6/lib -lX11" 6 | make linux -j16 CFLAGS="$MAKE_CFLAGS" LDFLAGS="$MAKE_LDFLAGS" LIBS="$MAKE_LIBS" 7 | mv -f psytexx ../BIN/psytexx_linux_x86_64_x11 -------------------------------------------------------------------------------- /log/log.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "core/core.h" 4 | 5 | void slog_disable(); 6 | void slog_enable(); 7 | void slog_set_output_file( const char* filename ); 8 | void slog_reset(); //remove the log file 9 | void slog_close(); //deinit 10 | void slog( const char* format, ... ); 11 | -------------------------------------------------------------------------------- /MAKE/MAKE_LINUX_X86_OPENGL: -------------------------------------------------------------------------------- 1 | set -e 2 | 3 | MAKE_CFLAGS="-O3 -m32 -DCOLOR32BITS -DOPENGL" 4 | MAKE_LDFLAGS="-O3 -m32" 5 | MAKE_LIBS="-L/usr/X11R6/lib -lX11 -lGL -lXext" 6 | make linux -j16 CFLAGS="$MAKE_CFLAGS" LDFLAGS="$MAKE_LDFLAGS" LIBS="$MAKE_LIBS" 7 | mv -f psytexx ../BIN/psytexx_linux_x86_opengl -------------------------------------------------------------------------------- /MAKE/MAKE_LINUX_X86_64_OPENGL: -------------------------------------------------------------------------------- 1 | set -e 2 | 3 | MAKE_CFLAGS="-O3 -m64 -DCOLOR32BITS -DOPENGL" 4 | MAKE_LDFLAGS="-O3 -m64" 5 | MAKE_LIBS="-L/usr/X11R6/lib -lX11 -lGL -lXext" 6 | make linux -j16 CFLAGS="$MAKE_CFLAGS" LDFLAGS="$MAKE_LDFLAGS" LIBS="$MAKE_LIBS" 7 | mv -f psytexx ../BIN/psytexx_linux_x86_64_opengl -------------------------------------------------------------------------------- /MAKE/palmos/armscript.ld: -------------------------------------------------------------------------------- 1 | OUTPUT_FORMAT("elf32-littlearm") 2 | OUTPUT_ARCH(arm) 3 | ENTRY(_Z15ARM_PalmOS_mainPKvPvPFmS0_mS0_mE) 4 | SEARCH_DIR(/usr/local/arm-elf/lib); 5 | SECTIONS 6 | { 7 | .text 0x00000000 : { *(arm_startup) *(text) *(.text.*) *(.gnu*) *(sec1) *(sec2) *(sec3) *(sec4) } 8 | .alldata : { *(.rodata) *(.rodata.*) *(.data) *(.bss) } 9 | .rel : { *(.data.rel.local) *(.data.rel) } 10 | .got : { *(.got) *(.got.plt) } 11 | } 12 | 13 | -------------------------------------------------------------------------------- /psytexx/win_psychannels.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | //INTERNAL STRUCTURES: 7 | 8 | struct channels_data 9 | { 10 | int this_window; 11 | 12 | int mouse_button; 13 | }; 14 | 15 | //FUNCTIONS: 16 | 17 | void channels_redraw( int win_num, window_manager* ); 18 | 19 | //WINDOW HANDLERS: 20 | 21 | int channels_handler( wm_event*, window_manager* ); //Channels (scopes) handler 22 | -------------------------------------------------------------------------------- /psytexx/win_popup.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | //INTERNAL STRUCTURES: 7 | 8 | struct popup_data 9 | { 10 | int this_window; 11 | 12 | const char *text; 13 | 14 | int result; 15 | int selected; 16 | 17 | int old_focus_window; 18 | }; 19 | 20 | //FUNCTIONS: 21 | 22 | int start_popup_blocked( 23 | const char *text, 24 | int x, int y, 25 | window_manager* ); 26 | 27 | //HANDLERS: 28 | 29 | //WINDOW HANDLERS: 30 | 31 | int popup_handler( wm_event*, window_manager* ); 32 | -------------------------------------------------------------------------------- /psytexx/win_psyconfig.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | //PROPERTIES: 7 | #define PROP_VOLUME ".prop_config_vol" 8 | 9 | //INTERNAL STRUCTURES: 10 | 11 | struct config_data 12 | { 13 | int this_window; 14 | 15 | int scroll_volume; 16 | int button_close; 17 | 18 | int volume_changed; //-1 - not changed; 0... - changed volume; 19 | }; 20 | 21 | //FUNCTIONS: 22 | 23 | //HANDLERS: 24 | 25 | int scroll_vol_handler( void *user_data, int win, window_manager* ); 26 | int button_cclose_handler( void *user_data, int win, window_manager* ); 27 | 28 | //WINDOW HANDLERS: 29 | 30 | int config_handler( wm_event*, window_manager* ); 31 | 32 | -------------------------------------------------------------------------------- /psytexx/win_psypatterntab.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | //INTERNAL STRUCTURES: 7 | 8 | struct patterntab_data 9 | { 10 | int this_window; //this window handler 11 | //Buttons: 12 | int button_inc; 13 | int button_dec; 14 | int button_ins; 15 | int button_del; 16 | }; 17 | 18 | //FUNCTIONS: 19 | 20 | //HANDLERS: 21 | 22 | int button_inc_handler( void* user_data, int button_win, window_manager* ); 23 | int button_dec_handler( void* user_data, int button_win, window_manager* ); 24 | int button_ins_handler( void* user_data, int button_win, window_manager* ); 25 | int button_del_handler2( void* user_data, int button_win, window_manager* ); 26 | 27 | //WINDOW HANDLERS: 28 | 29 | int patterntab_handler( wm_event*, window_manager* ); //Pattern properties 30 | -------------------------------------------------------------------------------- /MAKE/resources/palmos_resources.rcp: -------------------------------------------------------------------------------- 1 | ICONFAMILYEX 2 | BEGIN 3 | BITMAP "resources/22.bmp" BPP 1 4 | BITMAP "resources/22.bmp" BPP 2 5 | BITMAP "resources/22.bmp" BPP 8 TRANSPARENTINDEX 210 COMPRESS 6 | BITMAP "resources/44.bmp" BPP 1 DENSITY 2 7 | BITMAP "resources/44.bmp" BPP 2 DENSITY 2 8 | BITMAP "resources/44.bmp" BPP 8 TRANSPARENTINDEX 210 COMPRESS DENSITY 2 9 | END 10 | 11 | SMALLICONFAMILYEX 12 | BEGIN 13 | BITMAP "resources/15.bmp" BPP 1 14 | BITMAP "resources/15.bmp" BPP 2 15 | BITMAP "resources/15.bmp" BPP 8 TRANSPARENTINDEX 210 COMPRESS 16 | BITMAP "resources/30.bmp" BPP 1 DENSITY 2 17 | BITMAP "resources/30.bmp" BPP 2 DENSITY 2 18 | BITMAP "resources/30.bmp" BPP 8 TRANSPARENTINDEX 210 COMPRESS DENSITY 2 19 | END 20 | 21 | FORM ID 8888 AT (0 0 160 160) 22 | NOFRAME 23 | NOSAVEBEHIND 24 | USABLE 25 | BEGIN 26 | END -------------------------------------------------------------------------------- /sound/sound.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //Main sound header 4 | 5 | #include "../core/core.h" 6 | 7 | //Structures: 8 | 9 | enum 10 | { 11 | STATUS_STOP = 0, 12 | STATUS_PLAY, 13 | }; 14 | 15 | struct sound_struct 16 | { 17 | int status; //Current playing status 18 | int need_to_stop; //Set it to 1 if you want to stop sound stream 19 | volatile int stream_stoped; //If stream really stoped 20 | 21 | void *user_data; //Data for user defined render_piece_of_sound() 22 | 23 | int buflen; //Number of frames 24 | }; 25 | 26 | //Variables: 27 | 28 | extern void *user_sound_data; 29 | 30 | #ifdef OS_LINUX 31 | extern int dsp; 32 | #endif 33 | 34 | //Functions: 35 | 36 | int main_callback( void*, int, void*, int ); 37 | extern void render_piece_of_sound( signed short *buffer, int buffer_size, void *user_data ); 38 | 39 | void sound_stream_init(void); 40 | void sound_stream_play(void); 41 | void sound_stream_stop(void); 42 | void sound_stream_close(void); 43 | -------------------------------------------------------------------------------- /tiny_jpg/jpg.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | 5 | //PROGRESSIVE JPG IS NOT SUPPORTED! 6 | 7 | typedef struct 8 | { 9 | uint8_t bits[ 16 ]; 10 | uint8_t hval[ 256 ]; 11 | uint8_t size[ 256 ]; 12 | uint16_t code[ 256 ]; 13 | } jpeg_huffman_table_t; 14 | 15 | typedef struct 16 | { 17 | uint8_t* ptr; 18 | FILE* file; 19 | int width; 20 | int height; 21 | uint8_t* data; //ycbcr 22 | int data_precision; 23 | int num_components; 24 | int restart_interval; 25 | struct 26 | { 27 | int id; 28 | int h; 29 | int v; 30 | int t; 31 | int td; 32 | int ta; 33 | } component_info[ 3 ]; 34 | jpeg_huffman_table_t hac[ 4 ]; 35 | jpeg_huffman_table_t hdc[ 4 ]; 36 | int qtable[ 4 ][ 64 ]; 37 | struct 38 | { 39 | int ss, se; 40 | int ah, al; 41 | } scan; 42 | int dc[ 3 ]; 43 | int curbit; 44 | uint8_t curbyte; 45 | } jpeg_file_desc; 46 | 47 | //convert_to: 1 - grayscale; 2 - rgb; 48 | jpeg_file_desc* jpeg_load( const char* filename, FILE* f, int convert_to ); 49 | -------------------------------------------------------------------------------- /sound/sound_player.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | sound_player.cpp - main sound callback 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2007 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "sound.h" 9 | 10 | int main_callback( void *userData, 11 | int stream, 12 | void *_buffer, 13 | int frameCount ) 14 | { 15 | //main variables: ============ 16 | signed short *buffer = (signed short*) _buffer; 17 | int buffer_size = frameCount; 18 | sound_struct *U = (sound_struct*) userData; 19 | 20 | //clear buffer: ============== 21 | for( int i = 0; i < buffer_size * 2; i += 2 ) { buffer[ i ] = 0; buffer[ i + 1 ] = 0; } 22 | //============================ 23 | 24 | //for stream stop: =========== 25 | if( U->need_to_stop ) { U->stream_stoped = 1; return 0; } 26 | //============================ 27 | 28 | //render piece of sound: ===== 29 | render_piece_of_sound( buffer, buffer_size, U->user_data ); 30 | //============================ 31 | 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /psytexx/win_psysmpview.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | #define SAMPLE_MENU "SELECT ALL\nCUT\nCOPY\nPASTE\nCROP\nCLEAR\nSET LOOP\nSMOOTH\nNORMALIZE\nREVERSE" 7 | 8 | //PROPERTIES: 9 | 10 | //INTERNAL STRUCTURES: 11 | 12 | struct smpview_data 13 | { 14 | int this_window; 15 | 16 | int scrollbar; 17 | int precision_shift; 18 | 19 | short *prev_smp_data; 20 | int prev_smp_len; 21 | 22 | void *copy_buffer; 23 | 24 | int start_x; 25 | int start_y; 26 | int start_offset; 27 | int start_reppnt1; 28 | int start_reppnt2; 29 | int dragmode; //1 - cursor drag; 2 - reppnt1; 3 - reppnt2 30 | 31 | int offset; 32 | int delta; //Number of samples in one pixel 33 | 34 | int cursor; 35 | int selected_size; 36 | }; 37 | 38 | //FUNCTIONS: 39 | 40 | void smpview_edit_op( smpview_data *data, int op_num ); 41 | void smpview_zoom( int win_num, int inout, window_manager *wm ); 42 | void smpview_redraw( int win_num, window_manager *wm ); 43 | 44 | //HANDLERS: 45 | 46 | //WINDOW HANDLERS: 47 | 48 | int smpview_handler( wm_event*, window_manager* ); 49 | -------------------------------------------------------------------------------- /psytexx/win_dialog.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | //INTERNAL STRUCTURES: 7 | 8 | struct dialog_data 9 | { 10 | int this_window; 11 | int button_ok; 12 | int button_cancel; 13 | int current_button; 14 | 15 | const char *title; 16 | int title_len; 17 | 18 | int old_focus_window; 19 | 20 | void (*handler)(void*,int,window_manager*); 21 | void *user_data; 22 | }; 23 | 24 | extern int dialog_visible; 25 | 26 | //FUNCTIONS: 27 | 28 | void start_dialog( const char *text, const char *ok, const char *cancel, 29 | void (*)(void*, int, window_manager*), //(user data, pressed button, window_manager) 30 | void *user_data, 31 | int win_num, window_manager* ); 32 | 33 | int start_dialog_blocked( 34 | const char *text, const char *ok, const char *cancel, 35 | window_manager* ); 36 | 37 | //HANDLERS: 38 | 39 | int ok_button_handler( void *user_data, int button_win, window_manager* ); 40 | int cancel_button_handler( void *user_data, int button_win, window_manager* ); 41 | 42 | //WINDOW HANDLERS: 43 | 44 | int dialog_handler( wm_event*, window_manager* ); 45 | -------------------------------------------------------------------------------- /LICENSE: -------------------------------------------------------------------------------- 1 | MIT License 2 | 3 | Copyright (c) 2002 - 2024, Alexander Zolotov 4 | WarmPlace.ru 5 | 6 | Permission is hereby granted, free of charge, to any person obtaining a copy 7 | of this software and associated documentation files (the "Software"), to 8 | deal in the Software without restriction, including without limitation the 9 | rights to use, copy, modify, merge, publish, distribute, sublicense, and/or 10 | sell copies of the Software, and to permit persons to whom the Software is 11 | furnished to do so, subject to the following conditions: 12 | 13 | The above copyright notice and this permission notice shall be included in 14 | all copies or substantial portions of the Software. 15 | 16 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE 19 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 | FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS 22 | IN THE SOFTWARE. 23 | -------------------------------------------------------------------------------- /psytexx/win_psynet.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | //INTERNAL STRUCTURES: 7 | 8 | struct net_data 9 | { 10 | int this_window; 11 | 12 | int ctls_window; 13 | int win_menu; 14 | int new_button; 15 | 16 | int list_window; 17 | int list_window_opened; 18 | int items_list; 19 | int items_ok; 20 | int items_cancel; 21 | 22 | int selected_item; 23 | 24 | int new_item_x; //In precents 25 | int new_item_y; //In precents 26 | 27 | int link_drag; 28 | 29 | int drag_started; 30 | int drag_start_x; 31 | int drag_start_y; 32 | int drag_item_x; 33 | int drag_item_y; 34 | 35 | int offset_x; //In percents (0..1024) 36 | int offset_y; //In percents (0..1024) 37 | }; 38 | 39 | //FUNCTIONS: 40 | 41 | void net_redraw( net_data *data, window_manager *wm ); 42 | 43 | //HANDLERS: 44 | 45 | int new_button_handler( void *user_data, int button_win, window_manager *wm ); 46 | int item_ok_button_handler( void *user_data, int button_win, window_manager *wm ); 47 | int item_cancel_button_handler( void *user_data, int button_win, window_manager *wm ); 48 | 49 | //WINDOW HANDLERS: 50 | 51 | int net_handler( wm_event*, window_manager* ); 52 | -------------------------------------------------------------------------------- /psytexx/win_psysamples.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | extern int current_instrument; 7 | extern int current_sample; 8 | 9 | //INTERNAL STRUCTURES: 10 | 11 | struct samples_data 12 | { 13 | int this_window; 14 | int instruments_list; 15 | int samples_list; 16 | 17 | int ins_edit_button; 18 | int smp_edit_button; 19 | int ins_page_button; 20 | 21 | int button; 22 | int ins_or_smp; 23 | 24 | const char *old_ys2; 25 | 26 | int current_instrument; 27 | int current_sample; 28 | }; 29 | 30 | //FUNCTIONS: 31 | 32 | void samples_refresh( int win_num, window_manager* ); //Refresh instrument list 33 | void samples2_refresh( int win_num, window_manager* ); //Refresh sample list 34 | void unscale_top_win( samples_data *data, window_manager *wm ); 35 | 36 | //HANDLERS: 37 | 38 | int button_insteditor_handler( void *user_data, int win, window_manager *wm ); 39 | int button_smpeditor_handler( void *user_data, int win, window_manager *wm ); 40 | int smp_list_handler( void* user_data, int list_win, window_manager* ); 41 | int instr_list_handler( void* user_data, int list_win, window_manager* ); 42 | 43 | //WINDOW HANDLERS: 44 | 45 | int samples_handler( wm_event*, window_manager* ); 46 | -------------------------------------------------------------------------------- /psynth/psynth_net.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //Use it in your synths host 4 | 5 | #include "psynth.h" 6 | 7 | #define MAIN_OUTPUT_CHANNELS 2 8 | #define MAIN_INPUT_CHANNELS 2 9 | #ifdef PALMOS 10 | #define MAIN_BUFFER_SIZE 1024 11 | #else 12 | #define MAIN_BUFFER_SIZE 4096 13 | #endif 14 | 15 | //How to use: 16 | //1) psynth_render_clear() - clear buffers (output & external instruments) and "rendered" flags; 17 | //2) Render external synths to buffers; 18 | //3) Render external simple samplers to OUTPUT directly (adding); 19 | //4) Full net rendering (buffer size = user defined; not more then MAIN_BUFFER_SIZE). 20 | 21 | void psynth_init( psynth_net *pnet ); 22 | void psynth_close( psynth_net *pnet ); 23 | void psynth_clear( psynth_net *pnet ); 24 | void psynth_render_clear( psynth_net *pnet ); 25 | int psynth_add_synth( size_t (*synth)( 26 | PSYTEXX_SYNTH_PARAMETERS 27 | ), const char *name, int flags, int x, int y, int instr_num, psynth_net *pnet ); 28 | void psynth_remove_synth( int snum, psynth_net *pnet ); 29 | void psynth_make_link( int out, int in, psynth_net *pnet ); 30 | void psynth_remove_link( int out, int in, psynth_net *pnet ); 31 | void psynth_render( int start_item, int buf_size, psynth_net *pnet ); 32 | -------------------------------------------------------------------------------- /psytexx/win_psyinsteditor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | //PROPERTIES: 7 | 8 | //INTERNAL STRUCTURES: 9 | 10 | struct insteditor_data 11 | { 12 | int this_window; 13 | 14 | int pars_window; 15 | 16 | int scroll_volume; 17 | int scroll_pan; 18 | int scroll_finetune; 19 | int scroll_relative; 20 | int scroll_vibsweep; 21 | int scroll_vibdepth; 22 | int scroll_vibrate; 23 | int button_death; 24 | 25 | int button_close; 26 | }; 27 | 28 | //FUNCTIONS: 29 | 30 | void insteditor_redraw( int win_num, window_manager *wm ); 31 | 32 | //HANDLERS: 33 | 34 | int scroll_instvol_handler( void *user_data, int win, window_manager* ); 35 | int scroll_instpan_handler( void *user_data, int win, window_manager* ); 36 | int scroll_instfine_handler( void *user_data, int win, window_manager* ); 37 | int scroll_instrelative_handler( void *user_data, int win, window_manager *wm ); 38 | int scroll_instsweep_handler( void *user_data, int win, window_manager *wm ); 39 | int scroll_instdepth_handler( void *user_data, int win, window_manager *wm ); 40 | int scroll_instrate_handler( void *user_data, int win, window_manager *wm ); 41 | int button_iclose_handler( void *user_data, int win, window_manager* ); 42 | 43 | //WINDOW HANDLERS: 44 | 45 | int insteditor_handler( wm_event*, window_manager* ); 46 | -------------------------------------------------------------------------------- /psytexx/win_button.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | extern char txt_up[4]; 7 | extern char txt_down[4]; 8 | extern char txt_left[4]; 9 | extern char txt_right[4]; 10 | 11 | //INTERNAL STRUCTURES: 12 | 13 | struct button_data 14 | { 15 | int this_window; 16 | const char *name; //Button name 17 | int len; //Name length (in chars) 18 | char pressed; //If pressed 19 | int color; //Button color 20 | int x; //Name x-position (in pixels) 21 | int y; //Name y-position (in pixels) 22 | char autorepeat; //Auto-repeat mode ON/OFF 23 | char autorepeat_pressed; 24 | int (*handler)(void*,int,void*); //User defined handler: 25 | //handler(void *user_data, int button_window, void *window_manager) 26 | void *user_data; //Data for handler 27 | }; 28 | 29 | //FUNCTIONS: 30 | 31 | void button_set_color( COLOR color, int win_num, window_manager* ); 32 | void button_set_name( const char *name, int win_num, window_manager* ); 33 | void button_set_handler( int (*)(void*,int,window_manager*), void *user_data, int win_num, window_manager* ); 34 | void button_set_autorepeat( char autorepeat, int win_num, window_manager* wm ); 35 | 36 | //WINDOW HANDLERS: 37 | 38 | int button_handler( wm_event*, window_manager* ); //Button handler 39 | -------------------------------------------------------------------------------- /psytexx/win_psymenu.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | //INTERNAL STRUCTURES: 7 | 8 | struct menu_data 9 | { 10 | int play_button; 11 | int patplay_button; 12 | int stop_button; 13 | int net_button; 14 | int files_button; 15 | int playlist_button; 16 | int kbd_button; 17 | int config_button; 18 | int clear_button; 19 | 20 | int menu_button; 21 | 22 | int files_status; 23 | int config_status; 24 | int playlist_status; 25 | }; 26 | 27 | //FUNCTIONS: 28 | 29 | //HANDLERS: 30 | 31 | int play_button_handler( void *user_data, int button_win, window_manager* ); 32 | int patplay_button_handler( void *user_data, int button_win, window_manager* ); 33 | int stop_button_handler( void *user_data, int button_win, window_manager* ); 34 | int net_button_handler( void *user_data, int button_win, window_manager* ); 35 | int files_button_handler( void *user_data, int button_win, window_manager* ); 36 | int kbd_button_handler( void *user_data, int button_win, window_manager* ); 37 | int config_button_handler( void *user_data, int button_win, window_manager* ); 38 | int playlist_button_handler( void *user_data, int button_win, window_manager* ); 39 | int clear_button_handler( void *user_data, int button_win, window_manager* ); 40 | 41 | //WINDOW HANDLERS: 42 | 43 | int menu_handler( wm_event*, window_manager* ); 44 | -------------------------------------------------------------------------------- /psytexx/win_psysmpeditor.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | //PROPERTIES: 7 | 8 | //INTERNAL STRUCTURES: 9 | 10 | struct smpeditor_data 11 | { 12 | int this_window; 13 | 14 | int scroll_volume; 15 | int scroll_pan; 16 | int scroll_finetune; 17 | int scroll_relative; 18 | int smpview; 19 | 20 | int button_close; 21 | int button_loop; 22 | int button_menu; 23 | int button_zoomin; 24 | int button_zoomout; 25 | }; 26 | 27 | //FUNCTIONS: 28 | 29 | void smpeditor_redraw( int win_num, window_manager *wm ); 30 | void smpeditor_draw_info( int win_num, window_manager *wm ); 31 | 32 | //HANDLERS: 33 | 34 | int scroll_smpvol_handler( void *user_data, int win, window_manager* ); 35 | int scroll_smppan_handler( void *user_data, int win, window_manager* ); 36 | int scroll_smpfine_handler( void *user_data, int win, window_manager* ); 37 | int button_loop_handler( void *user_data, int win, window_manager* ); 38 | int button_menu_handler( void *user_data, int win_num, window_manager *wm ); 39 | int button_zoomin_handler( void *user_data, int win_num, window_manager *wm ); 40 | int button_zoomout_handler( void *user_data, int win_num, window_manager *wm ); 41 | int button_sclose_handler( void *user_data, int win, window_manager* ); 42 | 43 | //WINDOW HANDLERS: 44 | 45 | int smpeditor_handler( wm_event*, window_manager* ); 46 | -------------------------------------------------------------------------------- /psytexx/win_psypattern.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | extern int text_bpm; 7 | extern int text_speed; 8 | extern int text_patsize; 9 | extern int text_add; 10 | extern int text_channels; 11 | 12 | extern uint psytexx_start_time; 13 | extern uint play_start_time; 14 | extern uint playing_time; 15 | 16 | //INTERNAL STRUCTURES: 17 | 18 | struct pattern_data 19 | { 20 | int this_window; //this window handler 21 | //Text windows: 22 | int text_bpm; //Global BPM 23 | int text_speed; //Global Speed 24 | int text_patsize; //Current pattern size 25 | int text_add; //Write note step 26 | int text_channels; //Number of channels 27 | //Channels window: 28 | int channels; 29 | }; 30 | 31 | //FUNCTIONS: 32 | 33 | void psypattern_redraw_channels( int win_num, window_manager *wm ); 34 | void psypattern_draw_time( int win_num, window_manager *wm ); 35 | 36 | //HANDLERS: 37 | 38 | int text_bpm_handler( void* user_data, int button_win, window_manager* ); 39 | int text_speed_handler( void* user_data, int button_win, window_manager* ); 40 | int text_patsize_handler( void* user_data, int button_win, window_manager* ); 41 | int text_add_handler( void* user_data, int button_win, window_manager* ); 42 | int text_channels_handler( void* user_data, int button_win, window_manager* ); 43 | 44 | //WINDOW HANDLERS: 45 | 46 | int pattern_handler( wm_event*, window_manager* ); //Pattern properties 47 | -------------------------------------------------------------------------------- /core/core.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #define PSYTEXX_VERSION "PsyTexx2 alpha 0.6" 4 | #define PSYTEXX_DATE __DATE__ 5 | 6 | /* 7 | Engine configuration (possible defines) 8 | COLOR8BITS //8 bit color 9 | COLOR16BITS //16 bit color 10 | COLOR32BITS //32 bit color 11 | OS_UNIX //OS = some UNIX variation (Linux, FreeBSD...); POSIX-compatible 12 | OS_LINUX //OS = Linux 13 | OS_WIN //OS = Windows 14 | PALMOS //OS = PalmOS 15 | PALMOS_COMP_MODE //DEPRECATED 16 | NOSTORAGE //Do not use the Storage Heap and MemSemaphores 17 | PALMLOWRES //PalmOS low-density screen 18 | TEXTMODE //Linux Text Mode 19 | X11 //X11 support 20 | DIRECTX //DirectDraw support 21 | OPENGL //OpenGL support 22 | GDI //GDI support 23 | SLOWMODE //Slow mode for slow devices 24 | 25 | Variations 26 | WIN32: COLOR32BITS + OS_WIN [ + OPENGL / GDI ] 27 | LINUX: COLOR32BITS + OS_LINUX [ + TEXTMODE / OPENGL / X11 ] 28 | PALMOS: COLOR8BITS + PALMOS + SLOWMODE [ + NOSTORAGE / PALMLOWRES ] 29 | */ 30 | 31 | #ifdef OS_LINUX 32 | #define OS_UNIX 33 | #endif 34 | 35 | #ifndef PALMOS 36 | #include 37 | #include 38 | #include 39 | #include 40 | #include 41 | #include 42 | #define NONPALM 43 | #else 44 | #include 45 | #include "palm_functions.h" 46 | #endif 47 | 48 | typedef unsigned int uint; 49 | -------------------------------------------------------------------------------- /psynth/psynth_code_template.cpp: -------------------------------------------------------------------------------- 1 | #include "psynth.h" 2 | 3 | //Unique names for objects in your synth: 4 | #define SYNTH_DATA my_synth_data 5 | #define SYNTH_HANDLER synth 6 | //And unique parameters: 7 | #define SYNTH_INPUTS 2 8 | #define SYNTH_OUTPUTS 2 9 | 10 | struct SYNTH_DATA 11 | { 12 | //Controls: ############################################################ 13 | CTYPE ctl_volume; 14 | //Synth data: ########################################################## 15 | }; 16 | 17 | size_t SYNTH_HANDLER( 18 | PSYTEXX_SYNTH_PARAMETERS 19 | ) 20 | { 21 | SYNTH_DATA *data = (SYNTH_DATA*)data_ptr; 22 | size_t retval = 0; 23 | 24 | switch( command ) 25 | { 26 | case COMMAND_GET_DATA_SIZE: 27 | retval = sizeof( SYNTH_DATA ); 28 | break; 29 | 30 | case COMMAND_GET_SYNTH_NAME: 31 | retval = (size_t)"SynthName"; 32 | break; 33 | 34 | case COMMAND_GET_INPUTS_NUM: retval = SYNTH_INPUTS; break; 35 | case COMMAND_GET_OUTPUTS_NUM: retval = SYNTH_OUTPUTS; break; 36 | 37 | case COMMAND_GET_WIDTH: retval = 320; break; 38 | case COMMAND_GET_HEIGHT: retval = 200; break; 39 | 40 | case COMMAND_INIT: 41 | psynth_register_ctl( synth_id, "Volume", "amount", 0, 256, 128, &data->ctl_volume, net ); 42 | break; 43 | 44 | case COMMAND_CLEAN: 45 | break; 46 | 47 | case COMMAND_RENDER_REPLACE: 48 | 49 | break; 50 | 51 | case COMMAND_CLOSE: 52 | break; 53 | } 54 | 55 | return retval; 56 | } 57 | -------------------------------------------------------------------------------- /psytexx/win_main.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "core/core.h" 4 | #include "log/log.h" 5 | #include "wm/wm.h" 6 | #include "xm/xm.h" 7 | 8 | //###################################### 9 | //## PSYTEXX VARIABLES: ## 10 | //###################################### 11 | 12 | extern window_manager wm; //Window manager 13 | extern xm_struct xm; //Main XM sound structure; 14 | 15 | extern int win_desktop; //Desktop window 16 | extern int win_top; 17 | extern int win_files; //Files window 18 | extern int win_menu; //PsyTexx main menu 19 | extern int win_patterntable; //Pattern table 20 | extern int win_patterncontrol; 21 | extern int win_patterneditor; //Pattern editor 22 | extern int win_samples; //Instrument list 23 | extern int win_pattern_prop; //Pattern properties 24 | extern int win_config; //PsyTexx config window 25 | extern int win_playlist; //PsyTexx playlist 26 | extern int win_insteditor; //Instrument editor 27 | extern int win_smpeditor; //Sample editor 28 | extern int win_net; //Sound net with effects and synths 29 | extern int win_keyboard; //Virtual keyboard 30 | extern int win_dialog; 31 | extern int win_popup; 32 | 33 | //###################################### 34 | //## PSYTEXX FUNCTIONS: ## 35 | //###################################### 36 | 37 | void psy_windows_init( void ); 38 | void psy_event_loop( void ); 39 | void psy_windows_close( void ); 40 | void psy_wm_handler( window_manager *wm ); 41 | 42 | int handler_load_xm( void *user_data, int files_window, window_manager* ); 43 | int handler_save_xm( void *user_data, int files_window, window_manager* ); 44 | -------------------------------------------------------------------------------- /wm/wm_opengl.h: -------------------------------------------------------------------------------- 1 | /* 2 | wm_opengl.h - platform-dependent module : OpenGL functions 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #pragma once 9 | 10 | //################################# 11 | //## DEVICE DEPENDENT FUNCTIONS: ## 12 | //################################# 13 | 14 | void gl_init( void ) 15 | { 16 | /* set viewing projection */ 17 | glMatrixMode( GL_PROJECTION ); 18 | glFrustum( -0.5F, 0.5F, -0.5F, 0.5F, 0.0F, 3.0F ); 19 | 20 | /* position viewer */ 21 | glMatrixMode( GL_MODELVIEW ); 22 | //glTranslatef(0.0F, 0.0F, -2.2F); 23 | 24 | glClearDepth( 1.0f ); 25 | glDepthFunc( GL_LESS ); 26 | glEnable( GL_DEPTH_TEST ); 27 | //glEnable( GL_LIGHTING ); 28 | //glEnable( GL_LIGHT0 ); 29 | 30 | glEnable( GL_TEXTURE_2D ); 31 | glBindTexture( GL_TEXTURE_2D, 1 ); 32 | glTexParameteri( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR ); 33 | 34 | glEnable( GL_COLOR_MATERIAL ); 35 | glEnable( GL_BLEND ); 36 | glEnable( GL_LINE_SMOOTH ); 37 | glEnable( GL_LINE_SMOOTH_HINT ); 38 | glBlendFunc( GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA ); 39 | 40 | glPixelTransferi( GL_INDEX_SHIFT, 0 ); 41 | glPixelTransferi( GL_INDEX_OFFSET, 0 ); 42 | #ifdef COLOR8BITS 43 | glPixelTransferi( GL_MAP_COLOR, GL_TRUE ); 44 | #endif 45 | } 46 | 47 | void gl_resize( void ) 48 | { 49 | /* set viewport to cover the window */ 50 | glViewport( 0, 0, winWidth, winHeight ); 51 | } 52 | 53 | //################################# 54 | //################################# 55 | //################################# 56 | -------------------------------------------------------------------------------- /psytexx/win_psyplaylist.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | //PROPERTIES: 7 | #define PROP_PLAYLIST ".prop_playlist" 8 | 9 | //INTERNAL STRUCTURES: 10 | 11 | struct playlist_data 12 | { 13 | int this_window; 14 | 15 | int button_close; 16 | int button_addfile; 17 | int button_addfiles; 18 | int button_delfile; 19 | int button_up; 20 | int button_down; 21 | int button_clear; 22 | int button_play; 23 | int button_random; 24 | int button_next; 25 | int button_prev; 26 | 27 | int list_files; 28 | 29 | int current_selected; 30 | 31 | int random_mode; 32 | }; 33 | 34 | //FUNCTIONS: 35 | 36 | void playlist_play_selected( int win_num, window_manager *wm ); 37 | void playlist_select_next_track( int win_num, window_manager *wm ); 38 | void playlist_select_previous_track( int win_num, window_manager *wm ); 39 | void playlist_save( const char *filename, int win_num, window_manager *wm ); 40 | void playlist_load( const char *filename, int win_num, window_manager *wm ); 41 | 42 | //HANDLERS: 43 | 44 | int button_pclose_handler( void *user_data, int win, window_manager *wm ); 45 | int button_addfile_handler( void *user_data, int win, window_manager *wm ); 46 | int button_addfiles_handler( void *user_data, int win, window_manager *wm ); 47 | int button_delfile_handler( void *user_data, int win, window_manager *wm ); 48 | int button_pup_handler( void *user_data, int win, window_manager *wm ); 49 | int button_pdown_handler( void *user_data, int win, window_manager *wm ); 50 | int button_plplay_handler( void *user_data, int win, window_manager *wm ); 51 | int button_random_handler( void *user_data, int win, window_manager *wm ); 52 | int button_plnext_handler( void *user_data, int win, window_manager *wm ); 53 | int button_plprev_handler( void *user_data, int win, window_manager *wm ); 54 | 55 | //WINDOW HANDLERS: 56 | 57 | int playlist_handler( wm_event*, window_manager* ); 58 | -------------------------------------------------------------------------------- /memory/memory.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | 5 | enum 6 | { 7 | HEAP_DYNAMIC = 0, 8 | HEAP_STORAGE 9 | }; 10 | #define HEAP_MASK 3 11 | 12 | #ifndef MEM_FAST_MODE 13 | #ifndef PALMOS 14 | #define MEM_USE_NAMES 15 | #endif 16 | #endif 17 | 18 | #define MEM_MAX_NAME_SIZE 16 19 | struct mem_block_struct 20 | { 21 | uint32_t heap; 22 | size_t size; 23 | #ifdef MEM_USE_NAMES 24 | char name[ MEM_MAX_NAME_SIZE ]; 25 | #endif 26 | #ifndef MEM_FAST_MODE 27 | mem_block_struct* next; 28 | mem_block_struct* prev; 29 | #endif 30 | }; 31 | 32 | #define MEM_NEW( heap, size ) mem_new( heap, size, __FUNCTION__ ) 33 | 34 | //mem_new: 35 | //heap - heap number: 36 | //0 = dynamic heap for small blocks 37 | //1 = storage heap for large static blocks 38 | //size - block size 39 | int mem_free_all(); 40 | void* mem_new( unsigned int heap, size_t size, const char *name ); 41 | void mem_free( void *ptr ); 42 | void simple_mem_free( void* ptr ); 43 | void mem_set( void *ptr, size_t size, unsigned char value ); 44 | void* mem_resize( void *ptr, size_t size ); 45 | void mem_copy( void *dest, const void *src, size_t size ); 46 | int mem_cmp( const char *p1, const char *p2, size_t size ); 47 | void mem_strcat( char *dest, const char *src ); 48 | int mem_strcmp( const char *s1, const char *s2 ); 49 | int mem_strlen( const char *s ); 50 | char *mem_strdup( const char *s1 ); 51 | 52 | //Get info about memory block: 53 | uint32_t mem_get_heap( void *ptr ); 54 | size_t mem_get_size( void *ptr ); 55 | char *mem_get_name( void *ptr ); 56 | 57 | //Palm specific: 58 | void mem_on(void); //Storage protection ON 59 | void mem_off(void); //Storage protection OFF 60 | void mem_palm_normal_mode(void); //Switch to normal mode (Storage protection ON) 61 | void mem_palm_our_mode(void); //Switch back to our mode (Storage protection is ON or OFF) 62 | 63 | #ifdef PALMOS 64 | #include 65 | extern SysAppInfoPtr ai1, ai2, appInfo; 66 | extern unsigned short ownID; 67 | #endif 68 | -------------------------------------------------------------------------------- /psytexx/win_text.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | #define MAX_TEXT_LEN 512 7 | 8 | extern int NEW_TEXT_SIZE; 9 | 10 | //INTERNAL STRUCTURES: 11 | 12 | struct text_data 13 | { 14 | int this_window; 15 | 16 | int readonly; 17 | uint8_t *text; 18 | int text_len; 19 | int cursor_position; 20 | int shift_status; 21 | 22 | int numerical_flag; //Simple text field or numerical ( 0 or 1 ) 23 | int button_left; //Buttons for numerical text field 24 | int button_right; //... 25 | int min_value; //Value bounds for numerical text field 26 | int max_value; //... 27 | 28 | uint8_t *caption; //Text field caption ( default value = 0 ) 29 | 30 | int active; // = 0 after ENTER 31 | 32 | int (*handler)(void*,int,void*); //User defined handler: 33 | //handler(void *user_data, int text_window, void *window_manager) 34 | void *user_data; //Data for handler 35 | }; 36 | 37 | //FUNCTIONS: 38 | 39 | void text_set_text( int win_num, const char *text, window_manager* ); 40 | char* text_get_text( int win_num, window_manager* ); 41 | void text_set_readonly( int win_num, int readonly, window_manager* ); 42 | void text_set_numerical( int win_num, int numerical, window_manager* ); 43 | void text_set_caption( int win_num, const char *caption, window_manager* ); 44 | void text_set_bounds( int win_num, int min, int max, window_manager* ); 45 | void text_set_value( int win_num, int value, window_manager* ); 46 | int text_get_value( int win_num, window_manager* ); 47 | void text_set_handler( int (*)(void*,int,window_manager*), void *user_data, int win_num, window_manager* ); 48 | 49 | //HANDLERS: 50 | int button_left_handler( void* user_data, int button_win, window_manager* ); 51 | int button_right_handler( void* user_data, int button_win, window_manager* ); 52 | 53 | //WINDOW HANDLERS: 54 | 55 | int text_handler( wm_event*, window_manager* ); 56 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | **PsyTexx 2** is a cross-platform music tracker based on the XM (FastTracker eXtended Module) format. 2 | It is available for Linux (including text console mode), Windows and PalmOS. 3 | 4 | PsyTexx 2 is a logical continuation of PsyTexx 1.x, but with a new sound engine based on the XM format. 5 | In 2007, the project was frozen due to the start of the SunVox development. 6 | In 2024, i decided to make some changes and fix some bugs in the PsyTexx code so that it could be built on modern platforms. 7 | 8 | Non-standard (available only in PsyTexx) XM features: 9 | * each channel contains subchannels: instruments with a long envelope can continue to sound after NOTE OFF - this option can be enabled in the instrument editor; 10 | * stereo sample support; 11 | * effect I0 - sample play mode: 0 - normal; 1 - back direction; 2 - pause; 12 | * effect I1 - channel option: reduce sampling frequency; 13 | * effect I2 - channel option: reduce number of bits; 14 | 15 | Not implemented: 16 | * UTF-8 support; 17 | * instrument envelope editor; 18 | * the mouse drag event support in the console version - this code exists but for some reason it doesn't work. 19 | 20 | Source tree structure: 21 | * BIN - compiled versions, config file, background and font images; 22 | * DOCS - documentation; 23 | * MAKE - build scripts; 24 | * MUSIC - some of my music in the XM format; 25 | * core - base includes; 26 | * file - file management; 27 | * log - log management; 28 | * memory - memory management; 29 | * psynth - PsyTexx modular synth engine in early development; it later became SunVox; 30 | * psytexx - PsyTexx main and UI; 31 | * sound - sound output; 32 | * time - time management; 33 | * tiny_jpg - JPG loading; 34 | * wm - window manager (UI base); 35 | * xm - XM playback engine; 36 | 37 | Screenshots: 38 | 39 | ![PsyTexx2 alpha 0.6 on Linux](DOCS/psytexx2_alpha_0.6_2024_x11.jpg) 40 | ![PsyTexx2 alpha 0.6 on Palm Tungsten TX](DOCS/psytexx2_alpha_0.6_2024_palm.jpg) 41 | 42 | Please support my work: 43 | https://warmplace.ru/donate 44 | -------------------------------------------------------------------------------- /psytexx/win_scrollbar.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | #define BUTTON_SIZE 2 7 | #define BUTTON_SIZE_STR "2" 8 | 9 | extern char NEW_SCROLL_TYPE; 10 | 11 | //INTERNAL STRUCTURES: 12 | 13 | struct scrollbar_data 14 | { 15 | char type; //0 - vertical; 1 - horisontal 16 | int max; //Max value 17 | int cur; //Current value 18 | int scroll_size; //Scrollbar size (in pixels) without buttons 19 | int slider_size_items; //Size of real slider (in items) 20 | int slider_size; //Size of real slider (in pixels) 21 | int slider_pos; //Slider position (in pixels) 22 | int one_pixel_size; //Size of one pixel (in items). 10 bit fixed point value 23 | int step; //One step size (default = 4) 24 | 25 | int this_window; 26 | int button_up; 27 | int button_down; 28 | 29 | char pressed; //If pressed 30 | 31 | char we_are_in_slider; 32 | int start_x; 33 | int start_y; 34 | int start_value; 35 | 36 | char show_value_flag; 37 | char show_value_type; //0 - hex; 1 - dec 38 | int show_value_offset; 39 | 40 | int (*handler)(void*,int,void*); //User defined handler: 41 | //handler(void *user_data, int scrollbar_window, void *window_manager) 42 | void *user_data; //Data for handler 43 | }; 44 | 45 | //FUNCTIONS: 46 | 47 | void scrollbar_check( int win_num, window_manager* ); 48 | void scrollbar_draw( int win_num, window_manager* ); 49 | void scrollbar_set_parameters( int win_num, int type, int max, int cur, int slider_size_items, window_manager* ); 50 | void scrollbar_set_cur_value( int win_num, int cur, window_manager* ); 51 | void scrollbar_set_step( int win_num, int step, window_manager* ); 52 | void scrollbar_set_value_showing( int win_num, 53 | char show_value_flag, 54 | char show_value_type, 55 | int show_value_offset, 56 | window_manager *wm ); 57 | void scrollbar_set_handler( int (*)(void*,int,window_manager*), void *user_data, int win_num, window_manager* ); 58 | 59 | //HANDLERS: 60 | 61 | int up_handler( void* user_data, int button_win, window_manager* ); 62 | int down_handler( void* user_data, int button_win, window_manager* ); 63 | 64 | //WINDOW HANDLERS: 65 | 66 | int scrollbar_handler( wm_event*, window_manager* ); //Scrollbar handler 67 | -------------------------------------------------------------------------------- /xm/xm_song.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | xm_song.cpp - functions for working with song 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "xm.h" 9 | #include "../log/log.h" 10 | #include "../memory/memory.h" 11 | 12 | void close_song(xm_struct *xm) 13 | { 14 | module *song = xm->song; 15 | if( song ) mem_free( song ); 16 | xm->song = 0; 17 | } 18 | 19 | void clear_song(xm_struct *xm) 20 | { 21 | uint a; 22 | //clear patterns and instruments: 23 | for(a=0;a<256;a++) clear_pattern((uint16_t)a,xm); 24 | for(a=0;a<128;a++) clear_instrument((uint16_t)a,xm); 25 | 26 | module *song = xm->song; 27 | const char *temp_s = "Extended Module: "; 28 | int tp; 29 | for( tp = 0; tp < 17; tp++ ) song->id_text[ tp ] = temp_s[ tp ]; 30 | song->reserved1 = 0x1A; 31 | temp_s = "PsyTexx2 "; 32 | for( tp = 0; tp < 20; tp++ ) song->tracker_name[ tp ] = temp_s[ tp ]; 33 | for( tp = 0; tp < 20; tp++ ) song->name[ tp ] = 0; 34 | song->version = 0x0104; 35 | song->header_size = 0x114; 36 | song->length = 1; 37 | song->patterns_num = 1; 38 | song->patterntable[ 0 ] = 0; 39 | song->instruments_num = 0; 40 | song->restart_position = 0; 41 | xm->tablepos = 0; 42 | xm->patternpos = 0; 43 | 44 | #ifndef NOPSYNTH 45 | psynth_clear( xm->pnet ); 46 | #endif 47 | } 48 | 49 | 50 | void new_song( xm_struct *xm ) 51 | { 52 | uint a; 53 | module *song = xm->song; 54 | 55 | #ifndef NOPSYNTH 56 | psynth_clear( xm->pnet ); 57 | #endif 58 | 59 | //create new song: 60 | if(song != 0){ 61 | clear_song(xm); 62 | mem_free(song); 63 | 64 | song = (module*) mem_new( 0, sizeof( module ), "song" ); 65 | xm->song = song; 66 | }else{ //for FIRST song creation: 67 | song = (module*) mem_new( 0, sizeof( module ), "song" ); 68 | xm->song = song; 69 | //clear new song: 70 | for( a = 0; a < 128; a++ ) song->instruments[ a ] = 0; 71 | for( a = 0; a < 256; a++ ) song->patterns[ a ] = 0; 72 | //=============== 73 | } 74 | 75 | clear_song(xm); 76 | } 77 | 78 | void create_silent_song(xm_struct *xm) 79 | { 80 | module *song = xm->song; 81 | //Create simple silent song: 82 | song->channels = 4; 83 | new_pattern( 0, 64, 4, xm ); 84 | clean_pattern( 0, xm ); 85 | } 86 | 87 | void set_bpm( int bpm, xm_struct *xm ) 88 | { 89 | xm->bpm = bpm; 90 | xm->onetick = ( ( xm->freq * 25 ) << 8 ) / ( xm->bpm * 10 ); 91 | xm->patternticks = xm->onetick + 1; 92 | } 93 | 94 | void set_speed( int speed, xm_struct *xm ) 95 | { 96 | xm->speed = speed; 97 | xm->sp = xm->speed; 98 | } 99 | -------------------------------------------------------------------------------- /DOCS/manual/index.htm: -------------------------------------------------------------------------------- 1 | 2 | 3 | :: PsyTexx v2 manual :: 4 | 5 | 6 | 7 |
8 | What is Music Tracker?
9 | What is PsyTexx?
10 | PsyTexx user interface
11 | Keyboard shortcuts
12 | How to make
13 | Configuration
14 | PsyTexx Skins
15 | PsyTexx Fonts
16 | Contact info
17 | 18 |

19 | 20 | 21 |
22 |
23 | What is Music Tracker?

24 | Tracker is the generic term for a class of software music sequencers which, in their purest form, allow the user to arrange sound samples stepwise on a timeline across several channels. 25 | A tracker's interface is primarily numeric; notes are entered via the keyboard, whilst length, parameters, effects and so forth are entered in hexadecimal. A complete song consists of several small multi-channel patterns chained together via a master list. 26 |

27 | Read more: http://en.wikipedia.org/wiki/Tracker
28 |
29 | 30 | 31 |
32 |
33 | What is PsyTexx?

34 | PsyTexx is the cross-platform music tracker based on the XM (FastTracker eXtended Module) format. Currently it's available for Windows, Linux (X11 and text console) and PalmOS. 35 |

36 | Official homepage: WarmPlace.ru 37 |
38 |
39 | 40 | 41 |
42 |
43 | PsyTexx user interface

44 |
45 |

46 |

47 | 48 |
49 |
50 | 51 | 52 |
53 | Keyboard shortcuts

54 | Space - Record mode ON/OFF
55 | F1..F7 - Select octave 1..7
56 | Shift + F3 - Cut channel
57 | Shift + F4 - Copy channel
58 | Shift + F5 - Paste channel
59 | Ctrl + F3 - Cut pattern
60 | Ctrl + F4 - Copy pattern
61 | Ctrl + F5 - Paste pattern
62 | Tab - Go to next channel
63 | Shift + Tab - Go to previous channel
64 | Down - Go to next line
65 | Up - Go to previous line
66 | Escape - Exit to OS 67 |
68 |
69 | 70 | 71 |
72 | How to make

73 | Read HOW_TO_MAKE.txt in the MAKE directory.
74 |
75 |
76 | 77 | 78 |
79 | Configuration

80 | PsyTexx takes its configuration from the psytexx_config.ini file 81 | which must be in the current working directory (usually the same where the app is located).
82 |
83 | 84 | -------------------------------------------------------------------------------- /changelog.txt: -------------------------------------------------------------------------------- 1 | 2 | . . .. .: :: :: [ version 2 alpha 0.6 ] [ 25 oct 2024 ] :: :: :. .. .. . . 3 | 4 | # relicensed to MIT; 5 | # new platforms: Linux x86_64, Windows x86_64; 6 | # Linux: SDL2 sound output; 7 | # partially merged with SunDog engine; 8 | # code refactoring, minor improvements and bug fixes. 9 | 10 | . . .. .: :: :: [ version 2 alpha 0.5 ] [ 13 aug 2007 ] :: :: :. .. .. . . 11 | 12 | # Optimized MakeFile - one for the Linux and PalmOS. 13 | # Added simple piano keyboard. 14 | # Changed virtual keyboard; now it more minimalistic. 15 | # Improved real-time keyboard playing. 16 | # Removed multichannel arpeggio :). 17 | # Press CTRL + S for save BACKUP.XM. 18 | # Background images not supported temporary (it's for speed testing). 19 | # Added XI-instruments saving. 20 | # Added volume, panning, finetune and relative note controls for instruments. 21 | # Added new effect I0x - sample play mode: 0 - normal; 1 - back direction; 2 - pause. 22 | # Added new effect I1x - reduce sampling freq on a current channel. 23 | # Added new effect I2x - reduce number of bits on a current channel. 24 | # Fixed auto-vibrato. 25 | 26 | . . .. .: :: :: [ version 2 alpha 0.4 ] [ 02 jan 2007 ] :: :: :. .. .. . . 27 | 28 | # Added RAW-samples loading function. 29 | # Some windows redesigned. 30 | # Added "Clear comments" function. 31 | # Added two timers: working time and playing time. 32 | # He he... Multichannel arpeggio (0xx effect) was added. I like it :). 33 | # Click on a channel: left button - mute/unmute channel; right - solo channel/unmute all. 34 | # Added new font: 8x13. 35 | # Improved sample editor. 36 | # Added wave drawing to the channels view. 37 | # Fixed many different bugs. 38 | 39 | . . .. .: :: :: [ version 2 alpha 0.2 ] [ 21 may 2005 ] :: :: :. .. .. . . 40 | 41 | # Now PsyTexx works on the Tapwave Zodiac and the TungstenT5. 42 | # Fixed MOD loading and playing. 43 | # Fixed some bugs in XM playing. 44 | # Added playlist feature. 45 | # Fullscreen pattern editor. 46 | # Clear patterns/instruments feature. 47 | # Fixed bugs in filesystem. 48 | # Fixed bug with registering filetypes in ARM mode (PalmOS). 49 | # Filelist is sorted now. 50 | # Created first version of the PsyTexx2 manual (check the www.warmplace.ru). 51 | # and other... 52 | 53 | . . .. .: :: :: [ version 2 alpha 0.1 ] [ 20 march 2005 ] :: :: :. .. .. . . 54 | 55 | * Amiga MOD support. 56 | * XI (FastrTracker instruments) support (at the moment XI loading only). 57 | * WAV (8/16 bit, stereo/mono) support (at the moment WAV loading only). 58 | * Dynamic screen (or window) resizing. 59 | * Linux X11 support. 60 | * Realltime switching between standard and user (external font.bmp) font. 61 | * Auto storage memory cleaning after PsyTexx crash (PalmOS only). 62 | * Now you can click on the pattern view for changing of current cursor position. 63 | * Fixed some bugs. 64 | -------------------------------------------------------------------------------- /MAKE/HOW_TO_MAKE_PALMOS.txt: -------------------------------------------------------------------------------- 1 | 1) Download binutils-2.25 2 | 2) Configure and build it from another folder using the following commands: 3 | ../binutils-2.25/configure --target="arm-elf" --enable-interwork --enable-multilib 4 | make -j16 5 | sudo make install 6 | 7 | 3) Download gcc-4.5.4 8 | 4) Apply the patch #1 9 | 5) Download newlib-2.1.0; copy /newlib and /libgloss to gcc source root 10 | 6) Configure and build GCC from another folder using the folowing commands: 11 | ../gcc-4.5.4/configure --target="arm-elf" --enable-languages=c,c++ --with-newlib --with-gnu-as --with-gnu-ld --disable-multilib --enable-obsolete 12 | make -j16 all-gcc 13 | sudo make install 14 | 15 | 7) Install prc-tools-remix, PilRC and tools/setup-palm-os-sdk.sh from https://github.com/jichu4n/prc-tools-remix 16 | 8) Edit Makefile: set SDK to the correct PalmOS sdk-5 path (example: PALMOS_SDK = /opt/palmdev/sdk-5r3/include/) 17 | 18 | 9) Run MAKE_PALMOS script 19 | 20 | 10) Copy bin/psytexx_palmos.prc to the device SD card: PALM/PALM/Launcher 21 | If the app from the SD card crashes, it is recommended to delete its local copy: main launcher menu -> App -> Delete -> PsyTexx2 -> Delete. 22 | 23 | // 24 | // 25 | // 26 | 27 | !!!!!!!! 28 | Current version of the ARM code loader can't execute ARM-code with static functions 29 | !!!!!!!! 30 | 31 | // 32 | // 33 | // 34 | 35 | "arm-elf" target has been removed from GCC since 4.8. After 4.8, we can use "arm-none-eabi" instead, but I didn't have the time or patience to set it up properly. 36 | 37 | The following versions of the compilers have been tested, but, unfortunately, they produce code (apparently due to some kind of optimization) that is not compatible with my ARM loader :( 38 | GCC 4.7.4 39 | GCC 4.6.4 40 | 41 | GCC 4.5.4 works great. Something significant changed in code generation between versions 4.5.5 and 4.6. Perhaps someone can figure this out - I'd be grateful. 42 | 43 | // 44 | // 45 | // 46 | 47 | GCC PATCH #1 48 | 49 | diff --git a/gcc/cp/cfns.gperf b/gcc/cp/cfns.gperf 50 | index 68acd3d..953262f 100644 51 | --- a/gcc/cp/cfns.gperf 52 | +++ b/gcc/cp/cfns.gperf 53 | @@ -22,6 +22,9 @@ __inline 54 | static unsigned int hash (const char *, unsigned int); 55 | #ifdef __GNUC__ 56 | __inline 57 | +#ifdef __GNUC_STDC_INLINE__ 58 | +__attribute__ ((__gnu_inline__)) 59 | +#endif 60 | #endif 61 | const char * libc_name_p (const char *, unsigned int); 62 | %} 63 | diff --git a/gcc/cp/cfns.h b/gcc/cp/cfns.h 64 | index 1c6665d..6d00c0e 100644 65 | --- a/gcc/cp/cfns.h 66 | +++ b/gcc/cp/cfns.h 67 | @@ -53,6 +53,9 @@ __inline 68 | static unsigned int hash (const char *, unsigned int); 69 | #ifdef __GNUC__ 70 | __inline 71 | +#ifdef __GNUC_STDC_INLINE__ 72 | +__attribute__ ((__gnu_inline__)) 73 | +#endif 74 | #endif 75 | const char * libc_name_p (const char *, unsigned int); 76 | /* maximum key range = 391, duplicates = 0 */ 77 | 78 | -------------------------------------------------------------------------------- /psytexx/win_list.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | #define SCROLL_SIZE 2 7 | 8 | //INTERNAL STRUCTURES: 9 | 10 | #ifdef NOSTORAGE 11 | #define MAX_SIZE 16000 12 | #define MAX_ITEMS (int)4000 13 | #else 14 | #define MAX_SIZE 65000 15 | #define MAX_ITEMS (int)16000 16 | #endif 17 | 18 | struct list_data 19 | { 20 | int this_window; 21 | int button_up; //UP button 22 | int button_down; //DOWN button 23 | int scrollbar; //scrollbar window 24 | char *items; //Items data 25 | int *items_ptr; //Item pointers 26 | int items_num; //Number of items; 27 | int first_item; //First showed item; 28 | int selected_item; 29 | 30 | int numbered_flag; 31 | int number_offset; 32 | 33 | int pressed_button; //For the list handler 34 | 35 | char editable; //Editable flag (1/0) 36 | int edit_field; //Text window for editable lists 37 | 38 | int (*handler)(void*,int,void*); //User defined handler: 39 | //handler(void *user_data, int list_window, void *window_manager) 40 | void *user_data; //Data for handler 41 | }; 42 | 43 | //FUNCTIONS: 44 | 45 | void list_set_numbered( int numbered_flag, int offset, int win_num, window_manager* ); 46 | void list_set_editable( int editable_flag, int win_num, window_manager* ); 47 | void list_set_handler( int (*)(void*,int,window_manager*), void *user_data, int win_num, window_manager* ); 48 | void list_set_edit_handler( int (*)(void*,int,window_manager*), void *user_data, int win_num, window_manager* ); 49 | void list_draw( int win_num, window_manager* ); //Redraw list-window content 50 | void list_clear( int win_num, window_manager* ); //Clear list-window 51 | void list_reset_selection( int win_num, window_manager* ); 52 | void list_add_item( const char *item, char attr, int win_num, window_manager* );//Add new item (with attributes) to list-window 53 | void list_delete_item( int item_num, int win_num, window_manager* ); 54 | void list_move_item_up( int item_num, int win_num, window_manager* ); 55 | void list_move_item_down( int item_num, int win_num, window_manager* ); 56 | char list_get_attr( int item_num, int win_num, window_manager* ); //Get item's attribute 57 | char* list_get_item( int item_num, int win_num, window_manager* ); //Get item from the list-window 58 | int list_get_selected_num( int win_num, window_manager* ); //Get selected item number (or -1) 59 | int list_compare_items( int item1, int item2, int win_num, window_manager *wm ); 60 | void list_sort( int win_num, window_manager *wm ); 61 | void list_make_selection_visible( int win_num, window_manager *wm ); 62 | 63 | //HANDLERS: 64 | 65 | int scroll_handler( void* user_data, int scroll_window, window_manager* ); 66 | 67 | //WINDOW HANDLERS: 68 | 69 | int list_handler( wm_event*, window_manager* ); //List manager 70 | -------------------------------------------------------------------------------- /xm/xm_sample.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | xm_sample.cpp - functions for working with samples 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "xm.h" 9 | #include "../log/log.h" 10 | #include "../memory/memory.h" 11 | #include "../file/file.h" 12 | 13 | void new_sample( uint16_t num, 14 | uint16_t ins_num, 15 | const char *name, 16 | int length, /*length in bytes*/ 17 | int type, 18 | xm_struct *xm ) 19 | { 20 | module *song = xm->song; 21 | instrument *ins = song->instruments[ ins_num ]; 22 | sample *smp; //current sample 23 | signed short *data; 24 | int a; 25 | int created_size; 26 | 27 | smp = (sample*) mem_new( 0, sizeof(sample), "sample" ); 28 | 29 | //save sample parameters: 30 | for( a = 0 ; a < 22 ; a++ ) 31 | { 32 | smp->name[a] = name[a]; 33 | if( name[ a ] == 0 ) break; 34 | } 35 | 36 | //create NULL sample: 37 | smp->data = 0; 38 | 39 | //create sample data: 40 | slog( "SMP: Creating the sample data\n" ); 41 | if( length ) 42 | { 43 | data = (signed short*) mem_new( 1, length, "sample data" ); 44 | smp->data = (signed short*) data; 45 | created_size = length; 46 | }else{ //for NULL sample 47 | created_size = 0; 48 | } 49 | 50 | smp->length = created_size; 51 | smp->type = (uint8_t) type; 52 | 53 | smp->volume = 0x40; 54 | smp->panning = 0x80; 55 | smp->relative_note = 0; 56 | smp->finetune = 0; 57 | smp->reppnt = 0; 58 | smp->replen = 0; 59 | 60 | //save created sample: 61 | ins->samples[num] = smp; 62 | slog( "SMP: Sample was created\n" ); 63 | } 64 | 65 | void clear_sample(uint16_t num, uint16_t ins_num, xm_struct *xm) 66 | { 67 | module *song = xm->song; 68 | instrument *ins = song->instruments[ ins_num ]; 69 | sample *smp; 70 | signed short *smp_data; 71 | 72 | if( ins != 0 ) 73 | { 74 | smp = ins->samples[ num ]; 75 | if( smp != 0 ) 76 | { 77 | //clear sample data: 78 | smp_data = (signed short*) smp->data; 79 | if( smp_data != 0 ) 80 | { 81 | mem_free( smp_data ); 82 | } 83 | smp->data = 0; 84 | //================== 85 | mem_free( smp ); 86 | ins->samples[num] = 0; 87 | } 88 | } 89 | } 90 | 91 | void bytes2frames( sample *smp, xm_struct *xm ) 92 | { 93 | int bits = 8; 94 | int channels = 1; 95 | if( smp->type & 16 ) bits = 16; 96 | if( smp->type & 64 ) channels = 2; 97 | smp->length = smp->length / ( ( bits / 8 ) * channels ); 98 | smp->reppnt = smp->reppnt / ( ( bits / 8 ) * channels ); 99 | smp->replen = smp->replen / ( ( bits / 8 ) * channels ); 100 | } 101 | 102 | void frames2bytes( sample *smp, xm_struct *xm ) 103 | { 104 | int bits = 8; 105 | int channels = 1; 106 | if( smp->type & 16 ) bits = 16; 107 | if( smp->type & 64 ) channels = 2; 108 | smp->length = smp->length * ( ( bits / 8 ) * channels ); 109 | smp->reppnt = smp->reppnt * ( ( bits / 8 ) * channels ); 110 | smp->replen = smp->replen * ( ( bits / 8 ) * channels ); 111 | } 112 | 113 | -------------------------------------------------------------------------------- /DOCS/XM/xi.txt: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------- 2 | XI format description 3 | (FastTracker II Extended Instrument) 4 | reverse engineered by KB / The Obsessed Maniacs / Reflex 5 | Changed for PsyTexx/SunVox by Alexander Zolotov (2007-2024) 6 | -------------------------------------------------------------------------- 7 | C = Chars, B = Byte, W = Word, D = Double word 8 | 9 | Pos(h) Len(h) Meaning 10 | -------------------------------------------------------------- file header 11 | 0000 C15 "Extended Instrument: " 12 | 0015 C16 Instrument name, padded w/ spaces 13 | 14 | 002b B01 $1a 15 | 002c C14 Tracker name, padded w/ spaces 16 | 0040 W02 Version Number (current $0102) 17 | ($5050 - PsyTexx instrument) 18 | 19 | -------------------------------------------------------------- inst header 20 | 0042 B60 Sample number for notes 1..96 21 | 22 | 00a2 W30 12 volume envelope points: 23 | +0 Time index for Point 1 (ticks since note) 24 | +2 Volume for Point 1 (00..40) 25 | +4 Time index for Point 2 26 | +6 Volume for Point 2 27 | [...] 28 | 00d2 W30 12 panning envelope points 29 | (Same structure as volume envelope) 30 | 31 | 0102 B01 Number of volume points 32 | 0103 B01 Number of panning points 33 | 0104 B01 Volume sustain point 34 | 0105 B01 Volume loop start point 35 | 0106 B01 Volume loop end point 36 | 0107 B01 Panning sustain point 37 | 0108 B01 Panning loop start point 38 | 0109 B01 Panning loop end point 39 | 010a B01 Volume type; b0=on, b1=sustain, b2=loop 40 | 010b B01 Panning type; b0=on, b1=sustain, b2=loop 41 | 42 | 010c B01 Vibrato type 43 | 010d B01 Vibrato sweep 44 | 010e B01 Vibrato depth 45 | 010f B01 Vibrato rate 46 | 47 | 0110 W02 Volume fadeout (0..fff) 48 | 0112 B16 ????? (Zeroes or extened info for PsyTexx (vol,finetune,pan,relative,flags)) 49 | 50 | 0128 W02 Number of Samples 51 | 52 | ---------------------------------------------------------- sample headers 53 | 54 | 012a D04 Sample Length 55 | 012e D04 Sample loop start 56 | 0132 D04 Sample loop length 57 | 0136 B01 Volume 58 | 0137 B01 Finetune (signed) 59 | 0138 B01 Sample Type; b0,1=loop: 0=none 1=fwd 2=bidi 60 | b4 = 16bit sample 61 | non-standard extension 1: 62 | b5 = stereo; non-interleaved; 63 | non-standard extension 2: (PsyTexx/SunVox only; version == $5050) 64 | b5 = 32-bit (float) sampledata; [PsyTexx feature] 65 | b6 = stereo; interleaved; [PsyTexx feature] 66 | 0139 B01 Panning 67 | 013A B01 Relative Note (signed, 00=C-4) (call it Transpose) 68 | 013B B01 Sample Name Length 69 | 013C C16 Sample Name, padded w/ zeroes 70 | 71 | And so on w/ samples 1 to x 72 | Length: $28 bytes for each sample 73 | 74 | ------------------------------------------------------------- sample data 75 | 76 | $012a+(number of samples)*$28 : sample data for all samples in delta values 77 | (signed) 78 | 79 | -------------------------------------------------------------------------------- /psytexx/win_files.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | #include "../file/file.h" 6 | 7 | //FILE TYPES: 8 | #define MODFILES "xm/XM/mod/MOD" 9 | #define INSFILES "xi/XI/wav/WAV" 10 | 11 | //PROPERTIES: 12 | #define PROP_XMFILES_DIR ".prop_files_xm_" 13 | #define PROP_INSFILES_DIR ".prop_files_ins_" 14 | #define PROP_XMFILE_NAME ".prop_files_xmname_" 15 | #define PROP_INSFILE_NAME ".prop_files_insname_" 16 | 17 | //INTERNAL STRUCTURES: 18 | 19 | struct files_data 20 | { 21 | int this_window; //this window handler 22 | int list_window; //list window handler 23 | char disk_number; //current disk number 24 | char dir_name[MAX_DIR_LENGTH]; //current dir name (example: "mydir/") 25 | char full_path[MAX_DIR_LENGTH]; //full path (disk name + dir name [+ filename]) 26 | const char *current_mask; 27 | int button_up1; //".." button 28 | int button_up2; //"*.*" button 29 | int button_disk[16]; 30 | int button_load; 31 | int button_save; 32 | int button_del; 33 | int button_mods; 34 | int button_instr; 35 | int button_close; 36 | int current_files; //XM, INSTRUMENTS ... 37 | int text_filename; //Text windows: 38 | int text_file; // ... 39 | int text_dirname; // ... 40 | int text_dir; // ... 41 | 42 | int (*handler)(void*,int,void*); //User defined "LOAD" handler: 43 | //handler(void *user_data, int files_window, void *window_manager) 44 | void *user_data; //Data for handler 45 | 46 | int (*handler2)(void*,int,void*); //User defined "SAVE" handler: 47 | //handler2(void *user_data, int files_window, void *window_manager) 48 | void *user_data2; //Data for handler2 49 | }; 50 | 51 | //FUNCTIONS: 52 | 53 | void files_set_save_handler( int (*)(void*,int,window_manager*), void *user_data, int win_num, window_manager* ); 54 | void files_set_handler( int (*)(void*,int,window_manager*), void *user_data, int win_num, window_manager* ); 55 | void files_refresh( int win_num, window_manager* ); //Create files list 56 | int files_dir_up( int win_num, window_manager* ); //Go to the parent dir ("../" button) 57 | char* files_get_file( int win_num, window_manager* ); //Get full selected file name or NULL 58 | 59 | //HANDLERS: 60 | 61 | int button1_handler( void* user_data, int button_win, window_manager* ); 62 | int button2_handler( void* user_data, int button_win, window_manager* ); 63 | int button_load_handler( void* user_data, int button_win, window_manager* ); 64 | int button_save_handler( void* user_data, int button_win, window_manager* ); 65 | int button_del_handler( void* user_data, int button_win, window_manager* ); 66 | int button_mods_handler( void* user_data, int button_win, window_manager* ); 67 | int button_instr_handler( void* user_data, int button_win, window_manager* ); 68 | int button_close_handler( void* user_data, int button_win, window_manager* ); 69 | int disk_button_handler( void* user_data, int button_win, window_manager* ); 70 | int list_select_handler( void* user_data, int list_win, window_manager* ); 71 | 72 | //WINDOW HANDLERS: 73 | 74 | int files_handler( wm_event*, window_manager* ); //File manager 75 | -------------------------------------------------------------------------------- /psynth/psynths.cpp: -------------------------------------------------------------------------------- 1 | #include "psynth.h" 2 | 3 | //Unique names for objects in your synth: 4 | #define SYNTH_DATA psytexx_echo_data 5 | #define SYNTH_HANDLER psytexx_echo 6 | //And unique parameters: 7 | #define SYNTH_INPUTS 2 8 | #define SYNTH_OUTPUTS 2 9 | 10 | #define BUFFER_SIZE 44100 11 | 12 | struct SYNTH_DATA 13 | { 14 | //Controls: ############################################################ 15 | CTYPE ctl_volume; 16 | //Synth data: ########################################################## 17 | STYPE *buf[ SYNTH_OUTPUTS ]; 18 | int buf_ptr; 19 | }; 20 | 21 | size_t SYNTH_HANDLER( 22 | PSYTEXX_SYNTH_PARAMETERS 23 | ) 24 | { 25 | SYNTH_DATA *data = (SYNTH_DATA*)data_ptr; 26 | size_t retval = 0; 27 | int i; 28 | int ch; 29 | int prev_buf_ptr; 30 | 31 | switch( command ) 32 | { 33 | case COMMAND_GET_DATA_SIZE: 34 | retval = sizeof( SYNTH_DATA ); 35 | break; 36 | 37 | case COMMAND_GET_SYNTH_NAME: 38 | retval = (size_t)"Echo"; 39 | break; 40 | 41 | case COMMAND_GET_INPUTS_NUM: retval = SYNTH_INPUTS; break; 42 | case COMMAND_GET_OUTPUTS_NUM: retval = SYNTH_OUTPUTS; break; 43 | 44 | case COMMAND_INIT: 45 | psynth_register_ctl( synth_id, "Volume", "amount", 0, 256, 128, &data->ctl_volume, net ); 46 | for( i = 0; i < SYNTH_OUTPUTS; i++ ) 47 | { 48 | data->buf[ i ] = (STYPE*)SMALLOC( BUFFER_SIZE * sizeof( STYPE ) ); 49 | } 50 | data->buf_ptr = 0; 51 | for( i = 0; i < SYNTH_OUTPUTS; i++ ) 52 | { 53 | if( data->buf[ i ] ) SMEMSET( data->buf[ i ], 0, BUFFER_SIZE * sizeof( STYPE ) ); 54 | } 55 | break; 56 | 57 | case COMMAND_CLEAN: 58 | data->buf_ptr = 0; 59 | for( i = 0; i < SYNTH_OUTPUTS; i++ ) 60 | { 61 | if( data->buf[ i ] ) SMEMSET( data->buf[ i ], 0, BUFFER_SIZE * sizeof( STYPE ) ); 62 | } 63 | break; 64 | 65 | case COMMAND_RENDER_REPLACE: 66 | prev_buf_ptr = data->buf_ptr; 67 | for( ch = 0; ch < SYNTH_OUTPUTS; ch++ ) 68 | { 69 | data->buf_ptr = prev_buf_ptr; 70 | STYPE *in = inputs[ ch ]; 71 | STYPE *out = outputs[ ch ]; 72 | STYPE *cbuf = data->buf[ ch ]; 73 | for( i = 0; i < sample_frames; i++ ) 74 | { 75 | cbuf[ data->buf_ptr ] += in[ i ]; 76 | out[ i ] = cbuf[ data->buf_ptr ]; 77 | cbuf[ data->buf_ptr ] /= 2; 78 | data->buf_ptr++; 79 | if( data->buf_ptr >= BUFFER_SIZE ) data->buf_ptr = 0; 80 | } 81 | } 82 | break; 83 | 84 | case COMMAND_RENDER_ADD: 85 | prev_buf_ptr = data->buf_ptr; 86 | for( ch = 0; ch < SYNTH_OUTPUTS; ch++ ) 87 | { 88 | data->buf_ptr = prev_buf_ptr; 89 | STYPE *in = inputs[ ch ]; 90 | STYPE *out = outputs[ ch ]; 91 | STYPE *cbuf = data->buf[ ch ]; 92 | for( i = 0; i < sample_frames; i++ ) 93 | { 94 | cbuf[ data->buf_ptr ] += in[ i ]; 95 | out[ i ] += cbuf[ data->buf_ptr ]; 96 | cbuf[ data->buf_ptr ] /= 2; 97 | data->buf_ptr++; 98 | if( data->buf_ptr >= BUFFER_SIZE ) data->buf_ptr = 0; 99 | } 100 | } 101 | break; 102 | 103 | case COMMAND_CLOSE: 104 | for( i = 0; i < SYNTH_OUTPUTS; i++ ) 105 | { 106 | if( data->buf[ i ] ) SFREE( data->buf[ i ] ); 107 | } 108 | break; 109 | } 110 | 111 | return retval; 112 | } 113 | -------------------------------------------------------------------------------- /MAKE/palmos/palm_functions.h: -------------------------------------------------------------------------------- 1 | /* 2 | This file is public domain 3 | */ 4 | 5 | #ifndef __PALM_ARM_FUNCTIONS__ 6 | #define __PALM_ARM_FUNCTIONS__ 7 | 8 | #include 9 | #include "VFSMgr.h" 10 | #include "PceNativeCall.h" 11 | 12 | // Main structure for the ARM-main function 13 | struct ARM_INFO 14 | { 15 | void *GLOBALS; 16 | void *GOT; 17 | void *FORMHANDLER; 18 | long ID; 19 | long *new_screen_size; 20 | }; 21 | 22 | #define BSwap16(n) ( ((((unsigned long) n) <<8 ) & 0xFF00) | \ 23 | ((((unsigned long) n) >>8 ) & 0x00FF) ) 24 | 25 | #define BSwap32(n) ( ((((unsigned long) n) << 24 ) & 0xFF000000) | \ 26 | ((((unsigned long) n) << 8 ) & 0x00FF0000) | \ 27 | ((((unsigned long) n) >> 8 ) & 0x0000FF00) | \ 28 | ((((unsigned long) n) >> 24 ) & 0x000000FF) ) 29 | 30 | // local definition of the emulation state structure 31 | struct EmulStateType 32 | { 33 | UInt32 instr; 34 | UInt32 regData[8]; 35 | UInt32 regAddress[8]; 36 | UInt32 regPC; 37 | }; 38 | extern void *g_form_handler; 39 | extern long *g_new_screen_size; 40 | extern EmulStateType *emulStatePtr; 41 | extern Call68KFuncType *call68KFuncPtr; 42 | extern unsigned char args_stack[ 4 * 32 ]; 43 | extern unsigned char args_ptr; 44 | 45 | #define CALL_INIT \ 46 | emulStatePtr = (EmulStateType*)emulStateP; \ 47 | call68KFuncPtr = call68KFuncP; 48 | 49 | #define CALL args_ptr = 0; 50 | 51 | #define P1( par ) \ 52 | args_stack[ args_ptr ] = (unsigned char)par; args_ptr++; \ 53 | args_stack[ args_ptr ] = 0; args_ptr++; 54 | 55 | #define P2( par ) \ 56 | args_stack[ args_ptr ] = (unsigned char)((unsigned short)par>>8); args_ptr++; \ 57 | args_stack[ args_ptr ] = (unsigned char)((unsigned short)par&255); args_ptr++; 58 | 59 | #define P4( par ) \ 60 | args_stack[ args_ptr ] = (unsigned char)((unsigned long)par>>24); args_ptr++; \ 61 | args_stack[ args_ptr ] = (unsigned char)((unsigned long)par>>16); args_ptr++; \ 62 | args_stack[ args_ptr ] = (unsigned char)((unsigned long)par>>8); args_ptr++; \ 63 | args_stack[ args_ptr ] = (unsigned char)((unsigned long)par&255); args_ptr++; 64 | 65 | #define TRAP( trap ) \ 66 | (call68KFuncPtr) (emulStatePtr,PceNativeTrapNo(trap),args_stack,args_ptr); 67 | 68 | #define TRAPP( trap ) \ 69 | (call68KFuncPtr) (emulStatePtr,PceNativeTrapNo(trap),args_stack,args_ptr|kPceNativeWantA0); 70 | 71 | #define MemPtrFree(p) MemChunkFree(p) 72 | 73 | //Posix compatibility: 74 | 75 | typedef char int8_t; 76 | typedef unsigned char uint8_t; 77 | typedef short int16_t; 78 | typedef unsigned short uint16_t; 79 | typedef int int32_t; 80 | typedef unsigned int uint32_t; 81 | typedef unsigned int size_t; 82 | typedef unsigned int FILE; 83 | 84 | void* malloc( size_t size ); 85 | void* realloc( void* ptr, size_t size ); 86 | void free( void* ptr ); 87 | void* memcpy( void* destination, const void* source, size_t num ); 88 | int strcmp( const char* str1, const char* str2 ); 89 | const char* strstr( const char* str1, const char* str2 ); 90 | int memcmp( const char* p1, const char* p2, size_t size ); 91 | size_t strlen( const char* str1 ); 92 | char* strdup( const char* s1 ); 93 | 94 | FILE* fopen( const char* filename, const char* filemode ); 95 | int fclose( FILE* fpp ); 96 | void rewind( FILE* fpp ); 97 | int getc( FILE* fpp ); 98 | int ftell ( FILE* fpp ); 99 | int fseek( FILE* fpp, int offset, int access ); 100 | int feof( FILE* fpp ); 101 | size_t fread( void* ptr, size_t el_size, size_t elements, FILE* fpp ); 102 | size_t fwrite( const void* ptr, size_t el_size, size_t elements, FILE* fpp ); 103 | int fputc( int val, FILE* fpp ); 104 | int remove( const char* filename ); 105 | 106 | int sprintf( char* dest_str, const char* str, ... ); 107 | 108 | #endif //__PALM_ARM_FUNCTIONS__ 109 | -------------------------------------------------------------------------------- /time/time.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | time.cpp - time management 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "time.h" 9 | 10 | #ifdef OS_LINUX 11 | #include 12 | #endif 13 | #ifndef NONPALM 14 | #include 15 | #endif 16 | #ifdef OS_WIN 17 | #include 18 | #include 19 | #endif 20 | 21 | uint time_hours( void ) 22 | { 23 | #ifdef OS_LINUX 24 | //LINUX: 25 | time_t t; 26 | time( &t ); 27 | return localtime( &t )->tm_hour; 28 | #endif 29 | #ifndef NONPALM 30 | //PALM: 31 | DateTimeType t; 32 | TimSecondsToDateTime( TimGetSeconds(), &t ); 33 | return t.hour; 34 | #endif 35 | #ifdef OS_WIN 36 | //WINDOWS: 37 | time_t t; 38 | time( &t ); 39 | return localtime( &t )->tm_hour; 40 | #endif 41 | } 42 | 43 | uint time_minutes( void ) 44 | { 45 | #ifdef OS_LINUX 46 | //LINUX: 47 | time_t t; 48 | time( &t ); 49 | return localtime( &t )->tm_min; 50 | #endif 51 | #ifndef NONPALM 52 | //PALM: 53 | DateTimeType t; 54 | TimSecondsToDateTime( TimGetSeconds(), &t ); 55 | return t.minute; 56 | #endif 57 | #ifdef OS_WIN 58 | //WINDOWS: 59 | time_t t; 60 | time( &t ); 61 | return localtime( &t )->tm_min; 62 | #endif 63 | } 64 | 65 | uint time_seconds( void ) 66 | { 67 | #ifdef OS_LINUX 68 | //LINUX: 69 | time_t t; 70 | time( &t ); 71 | return localtime( &t )->tm_sec; 72 | #endif 73 | #ifndef NONPALM 74 | //PALM: 75 | DateTimeType t; 76 | TimSecondsToDateTime( TimGetSeconds(), &t ); 77 | return t.second; 78 | #endif 79 | #ifdef OS_WIN 80 | //WINDOWS: 81 | time_t t; 82 | time( &t ); 83 | return localtime( &t )->tm_sec; 84 | #endif 85 | } 86 | 87 | uint time_ticks_per_second( void ) 88 | { 89 | #ifdef OS_LINUX 90 | //LINUX: 91 | return 1000; 92 | #endif 93 | #ifndef NONPALM 94 | //PALM: 95 | return SysTicksPerSecond(); 96 | #endif 97 | #ifdef OS_WIN 98 | //WINDOWS: 99 | return 1000; 100 | #endif 101 | } 102 | 103 | uint time_ticks( void ) 104 | { 105 | #ifdef OS_LINUX 106 | //LINUX: 107 | time_t tt; 108 | time( &tt ); 109 | 110 | timespec t; 111 | clock_gettime( CLOCK_REALTIME, &t ); 112 | return ( localtime( &tt )->tm_hour * 3600000 ) + 113 | ( localtime( &tt )->tm_min * 60000 ) + 114 | ( localtime( &tt )->tm_sec * 1000 ) + 115 | ( t.tv_nsec / 1000000 ); 116 | #endif 117 | #ifndef NONPALM 118 | //PALM: 119 | return TimGetTicks(); 120 | #endif 121 | #ifdef OS_WIN 122 | //WINDOWS: 123 | return GetTickCount(); 124 | #endif 125 | } 126 | 127 | void time_sleep( int milliseconds ) 128 | { 129 | #ifdef OS_UNIX 130 | #if defined(OS_APPLE) 131 | while( 1 ) 132 | { 133 | int t = milliseconds; 134 | if( t > 1000 ) t = 1000; 135 | usleep( t * 1000 ); 136 | milliseconds -= t; 137 | if( milliseconds <= 0 ) break; 138 | } 139 | #else 140 | #ifdef OS_EMSCRIPTEN 141 | emscripten_sleep( milliseconds ); 142 | #else 143 | timeval t; 144 | t.tv_sec = milliseconds / 1000; 145 | t.tv_usec = ( milliseconds % 1000 ) * 1000; 146 | select( 0 + 1, 0, 0, 0, &t ); 147 | #endif 148 | #endif 149 | #endif 150 | #if defined(OS_WIN) || defined(OS_WINCE) 151 | Sleep( milliseconds ); 152 | #endif 153 | #ifdef PALMOS 154 | volatile uint t = time_ticks(); 155 | uint len = ( milliseconds * time_ticks_per_second() ) / 1000; 156 | while( 1 ) 157 | { 158 | volatile uint t2 = time_ticks(); 159 | if( t2 - t >= len ) break; 160 | } 161 | #endif 162 | } 163 | -------------------------------------------------------------------------------- /psynth/psynth.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //Use it in your synth code 4 | 5 | //SunDog Engine include files: 6 | #include "../core/core.h" 7 | #include "../memory/memory.h" 8 | 9 | enum { 10 | COMMAND_NOP = 0, 11 | COMMAND_GET_DATA_SIZE, 12 | COMMAND_GET_SYNTH_NAME, 13 | COMMAND_GET_INPUTS_NUM, 14 | COMMAND_GET_OUTPUTS_NUM, 15 | COMMAND_GET_WIDTH, 16 | COMMAND_GET_HEIGHT, 17 | COMMAND_INIT, 18 | COMMAND_CLEAN, //Clean all data in sound buffers to 0 19 | COMMAND_RENDER_REPLACE, //Replace data in the destination buffer 20 | COMMAND_RENDER_ADD, //Add data to the destination buffer 21 | COMMAND_CLOSE 22 | }; 23 | 24 | #define PSYTEXX_SYNTH_PARAMETERS \ 25 | void *data_ptr, \ 26 | int synth_id, \ 27 | STYPE **inputs, \ 28 | STYPE **outputs, \ 29 | int sample_frames, \ 30 | int command, \ 31 | void *net 32 | 33 | //Control type: 34 | typedef int CTYPE; 35 | 36 | //Sample operations (selected by user): 37 | //==== Float ==== 38 | //Sample type: 39 | /* 40 | typedef float STYPE; 41 | #define INT16_TO_STYPE( res, val ) { res = (float)val / (float)32768; } 42 | #define STYPE_TO_INT16( res, val ) { \ 43 | int temp_res; \ 44 | temp_res = (int)( val * (float)32768 ); \ 45 | if( temp_res > 32767 ) res = 32767; else \ 46 | if( temp_res < -32768 ) res = -32768; else \ 47 | res = (signed short)temp_res; \ 48 | } 49 | */ 50 | //==== Int ==== 51 | //Sample type: 52 | typedef int STYPE; 53 | #define INT16_TO_STYPE( res, val ) { res = (int)val; } 54 | #define STYPE_TO_INT16( res, val ) { \ 55 | if( val > 32767 ) res = 32767; else \ 56 | if( val < -32768 ) res = -32768; else \ 57 | res = (signed short)val; \ 58 | } 59 | 60 | struct psynth_control 61 | { 62 | const char *ctl_name; //For example: "Delay", "Feedback" 63 | const char *ctl_label; //For example: "dB", "samples" 64 | CTYPE ctl_min; 65 | CTYPE ctl_max; 66 | CTYPE ctl_def; 67 | }; 68 | 69 | //One item of external net: 70 | #define PSYNTH_FLAG_EXISTS 1 71 | #define PSYNTH_FLAG_OUTPUT 2 72 | #define PSYNTH_FLAG_EXTERNAL_INSTRUMENT 4 73 | #define PSYNTH_FLAG_RENDERED 8 74 | #define PSYNTH_MAX_CHANNELS 8 75 | struct psynth_net_item 76 | { 77 | int flags; 78 | 79 | char item_name[ 32 ]; 80 | 81 | size_t (*synth)( 82 | PSYTEXX_SYNTH_PARAMETERS 83 | ); 84 | void *data_ptr; 85 | STYPE *channels[ PSYNTH_MAX_CHANNELS ]; 86 | 87 | int x, y; //In percents (0..1024) 88 | int instr_num; 89 | 90 | //Number of channels: 91 | int input_channels; 92 | int output_channels; 93 | 94 | //Links to an input synths: 95 | int *input_links; 96 | int input_num; 97 | 98 | //Controllers: 99 | psynth_control ctls[ 16 ]; 100 | int ctls_num; 101 | }; 102 | 103 | //External sound net (created by host): 104 | struct psynth_net 105 | { 106 | //Net items (nodes): 107 | psynth_net_item *items; 108 | int items_num; 109 | //Some info: 110 | int sampling_freq; 111 | char is_external_instr_in_the_net[ 128 ]; 112 | }; 113 | 114 | extern void psynth_register_ctl( 115 | int synth_id, 116 | const char *ctl_name, //For example: "Delay", "Feedback" 117 | const char *ctl_label, //For example: "dB", "samples" 118 | CTYPE ctl_min, 119 | CTYPE ctl_max, 120 | CTYPE ctl_def, 121 | CTYPE *value, 122 | void *net ); 123 | 124 | //Platform dependent functions: 125 | #define SMALLOC( size ) MEM_NEW( HEAP_DYNAMIC, size ) 126 | #define SREALLOC( ptr, size ) mem_resize( ptr, size ) 127 | #define SMEMSET( ptr, val, size ) mem_set( ptr, size, val ) 128 | #define SFREE( ptr ) mem_free( ptr ) 129 | -------------------------------------------------------------------------------- /xm/xm_pattern.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | xm_pattern.cpp - functions for working with a patterns 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "xm.h" 9 | #include "../log/log.h" 10 | #include "../memory/memory.h" 11 | 12 | void new_pattern( uint16_t num, 13 | uint16_t rows, 14 | uint16_t channels, 15 | xm_struct *xm ) 16 | { 17 | module *song = xm->song; 18 | pattern *pat; 19 | 20 | //create pattern structure: 21 | pat = (pattern*) mem_new( 0, sizeof(pattern), "pattern" ); 22 | 23 | //save created structure pointer: 24 | song->patterns[ num ] = pat; 25 | 26 | pat->header_length = 9; //pattern header length 27 | pat->reserved5 = 0; //non packed 28 | pat->real_rows = pat->rows = rows; //number of rows in new pattern 29 | pat->real_channels = pat->channels = channels; 30 | pat->data_size = rows * channels * sizeof(xmnote); //physical size of pattern 31 | 32 | //Create memory block for the current pattern: 33 | pat->pattern_data = (xmnote*) mem_new( HEAP_STORAGE, pat->data_size, "pattern data" ); 34 | } 35 | 36 | #ifndef XM_PLAYER 37 | 38 | //We can change one parameter (rows or channels) only at the time 39 | void resize_pattern( uint16_t num, 40 | uint16_t rows, 41 | uint16_t channels, 42 | xm_struct *xm ) 43 | { 44 | module *song = xm->song; 45 | pattern *pat; 46 | 47 | pat = song->patterns[ num ]; 48 | if( pat == 0 ) return; 49 | 50 | if( channels > pat->real_channels || rows > pat->real_rows ) 51 | { 52 | int new_size = rows * channels * sizeof(xmnote); 53 | xmnote *new_pat = (xmnote*)mem_new( HEAP_STORAGE, new_size, "pattern data" ); 54 | mem_set( new_pat, new_size, 0 ); 55 | for( int y = 0; y < rows; y++ ) 56 | { 57 | for( int x = 0; x < channels; x++ ) 58 | { 59 | if( x < pat->real_channels && y < pat->real_rows ) 60 | new_pat[ y * channels + x ] = pat->pattern_data[ y * pat->real_channels + x ]; 61 | } 62 | } 63 | mem_free( pat->pattern_data ); 64 | pat->pattern_data = new_pat; 65 | pat->channels = pat->real_channels = channels; 66 | pat->rows = pat->real_rows = rows; 67 | } 68 | else 69 | { 70 | pat->rows = rows; 71 | pat->channels = channels; 72 | } 73 | } 74 | 75 | #endif 76 | 77 | void clear_pattern( uint16_t num, xm_struct *xm ) 78 | { 79 | module *song = xm->song; 80 | pattern *pat = song->patterns[ num ]; 81 | xmnote *pat_data; 82 | 83 | if( pat != 0 ) 84 | { 85 | //clear pattern data: 86 | pat_data = pat->pattern_data; 87 | if( pat_data != 0 ) 88 | { 89 | mem_free( pat_data ); 90 | } 91 | pat->pattern_data = 0; 92 | //=================== 93 | mem_free( pat ); 94 | } 95 | song->patterns[num] = 0; 96 | } 97 | 98 | void clear_patterns(xm_struct *xm) 99 | { 100 | uint a; 101 | //clear patterns: 102 | for( a=0; a < 256; a++ ) clear_pattern( (uint16_t)a, xm ); 103 | 104 | module *song = xm->song; 105 | song->length = 1; 106 | song->patterns_num = 1; 107 | song->patterntable[ 0 ] = 0; 108 | song->restart_position = 0; 109 | xm->tablepos = 0; 110 | xm->patternpos = 0; 111 | } 112 | 113 | void clean_pattern( uint16_t num, xm_struct *xm ) 114 | { 115 | module *song = xm->song; 116 | pattern *pat = song->patterns[ num ]; 117 | uint8_t *pat_data; 118 | uint a, rows, channels; 119 | 120 | if( pat != 0 ) 121 | { 122 | //clean pattern data: 123 | pat_data = (uint8_t*) pat->pattern_data; 124 | if( pat_data != 0 ) 125 | { 126 | rows = pat->rows; 127 | channels = song->channels; 128 | for( a = 0; a < rows * channels * sizeof(xmnote); a++ ) 129 | { 130 | pat_data[ a ] = 0; 131 | } 132 | } 133 | //=================== 134 | } 135 | } 136 | -------------------------------------------------------------------------------- /psytexx/main.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | psytexx.cpp - PsyTexx main() 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "win_main.h" 9 | 10 | //################################ 11 | //## DEVICE VARIABLES: ## 12 | //################################ 13 | 14 | #ifdef PALMOS 15 | #include 16 | #define arm_startup __attribute__ ((section ("arm_startup"))) 17 | #include "palm_functions.h" 18 | #endif 19 | 20 | //################################ 21 | //################################ 22 | //################################ 23 | 24 | //################################ 25 | //## APPLICATION MAIN: ## 26 | //################################ 27 | 28 | int g_argc = 0; 29 | char* g_argv[ 64 ]; 30 | 31 | //******************************** 32 | //WIN32 MAIN ********************* 33 | #ifdef OS_WIN 34 | int APIENTRY WinMain(HINSTANCE hCurrentInst, HINSTANCE hPreviousInst, LPSTR lpszCmdLine, int nCmdShow) 35 | { 36 | { 37 | #endif 38 | //******************************** 39 | //******************************** 40 | 41 | //******************************** 42 | //PALMOS MAIN ******************** 43 | #ifdef PALMOS 44 | int ARM_PalmOS_main( const void *emulStateP, void *userData, Call68KFuncType *call68KFuncP ) arm_startup; 45 | int ARM_PalmOS_main( const void *emulStateP, void *userData, Call68KFuncType *call68KFuncP ) 46 | { 47 | { 48 | volatile void* oldGOT; 49 | volatile register void* gGOT asm ("r10"); 50 | volatile ARM_INFO* arm_info = (ARM_INFO *)userData; 51 | oldGOT = (void*)gGOT; 52 | //gGOT = (void *)arm_info->GOT; 53 | volatile unsigned int newgot = (unsigned int)arm_info->GOT; 54 | __asm__ ( "mov r10, %0" : : "r" (newgot) ); 55 | ownID = (unsigned short)arm_info->ID; 56 | g_form_handler = arm_info->FORMHANDLER; //g_form_handler is defined in palm_functions.cpp 57 | g_new_screen_size = arm_info->new_screen_size; 58 | CALL_INIT 59 | int autooff_time = SysSetAutoOffTime( 0 ); 60 | g_argc = 1; 61 | g_argv[ 0 ] = (char*)"prog"; 62 | int argc = g_argc; 63 | char** argv = g_argv; 64 | #endif //PALMOS 65 | //******************************** 66 | //******************************** 67 | 68 | //******************************** 69 | //LINUX MAIN ********************* 70 | #ifdef OS_LINUX 71 | int main(int argc, char *argv[]) 72 | { 73 | { 74 | wm.argc = argc; 75 | wm.argv = argv; 76 | #ifdef TEXTMODE 77 | char* str; 78 | if( argc > 1 ) 79 | { 80 | str = argv[ 1 ]; 81 | if( str[ 0 ] == '-' || str[ 0 ] == '?' ) 82 | { 83 | printf( "\033[%dm\033[%dm", 37, 40 ); 84 | printf( "PsyTexx 2 for Linux.\n" ); 85 | printf( "\033[%dm\033[%dm", 36, 40 ); 86 | printf( "Command line options:\n" ); 87 | printf( "\033[%dm\033[%dm", 35, 40 ); 88 | printf( "m - auto mouse key up (for some GPM versions)\n" ); 89 | printf( "\033[%dm\033[%dm", 37, 40 ); 90 | return 0; 91 | } 92 | if( str[ 0 ] == 'm' ) mouse_auto_keyup = 1; 93 | } 94 | #endif 95 | #endif 96 | //******************************** 97 | //******************************** 98 | 99 | slog_reset(); 100 | 101 | slog( "\n" ); 102 | slog( "\n" ); 103 | slog( PSYTEXX_VERSION "\n" ); 104 | slog( PSYTEXX_DATE "\n" ); 105 | slog( "\n" ); 106 | slog( "STARTING...\n" ); 107 | slog( "\n" ); 108 | slog( "\n" ); 109 | 110 | mem_set( &wm, sizeof( window_manager ), 0 ); 111 | #ifdef OS_WIN 112 | wm.hCurrentInst = hCurrentInst; 113 | wm.hPreviousInst = hPreviousInst; 114 | wm.lpszCmdLine = lpszCmdLine; 115 | wm.nCmdShow = nCmdShow; 116 | #endif 117 | 118 | get_disks(); 119 | psy_windows_init(); 120 | psy_event_loop(); 121 | psy_windows_close(); 122 | 123 | slog_close(); 124 | mem_free_all(); //Close all memory blocks 125 | 126 | slog( "\n" ); 127 | slog( "\n" ); 128 | slog( "BYE !\n" ); 129 | slog( "\n" ); 130 | slog( "\n" ); 131 | 132 | #ifdef PALMOS 133 | SysSetAutoOffTime( autooff_time ); 134 | //gGOT = (void*)oldGOT; 135 | newgot = (unsigned int)oldGOT; 136 | __asm__ ( "mov r10, %0" : : "r" (newgot) ); 137 | #endif 138 | } 139 | 140 | return 0; 141 | } 142 | 143 | //################################ 144 | //################################ 145 | //################################ 146 | -------------------------------------------------------------------------------- /log/log.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | log.cpp - log management 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "log.h" 9 | #include "../memory/memory.h" 10 | #include "../wm/wm.h" 11 | 12 | #define PALMOS_Y_LIMIT 70 13 | 14 | static int g_slog_disable_counter = 0; 15 | 16 | void slog_disable() 17 | { 18 | g_slog_disable_counter++; 19 | } 20 | 21 | void slog_enable() 22 | { 23 | if( g_slog_disable_counter > 0 ) 24 | g_slog_disable_counter--; 25 | } 26 | 27 | static int g_slog_count = 0; 28 | static char g_slog_tmp_buf[ 256 ]; 29 | static char* g_slog_buf = 0; 30 | static int g_slog_buf_size = 0; 31 | static int y = 10; 32 | 33 | static const char* g_slog_file = "log.txt"; 34 | 35 | void slog_set_output_file( const char *filename ) 36 | { 37 | g_slog_file = filename; 38 | } 39 | 40 | void slog_reset() 41 | { 42 | #ifdef NONPALM 43 | remove( g_slog_file ); 44 | #endif 45 | } 46 | 47 | void slog_close() 48 | { 49 | if( g_slog_buf && g_slog_buf != g_slog_tmp_buf ) 50 | { 51 | mem_free( g_slog_buf ); 52 | g_slog_buf = g_slog_tmp_buf; 53 | g_slog_buf_size = 256; 54 | } 55 | } 56 | 57 | void slog( const char* format, ... ) 58 | { 59 | if( g_slog_disable_counter ) return; 60 | 61 | va_list p; 62 | va_start( p, format ); 63 | if( g_slog_buf_size == 0 ) 64 | { 65 | g_slog_buf = g_slog_tmp_buf; 66 | g_slog_buf_size = 256; 67 | g_slog_buf = (char*)MEM_NEW( HEAP_DYNAMIC, 256 ); 68 | } 69 | int ptr = 0; 70 | int ptr2 = 0; 71 | char num_str[ 64 ]; 72 | int len; 73 | 74 | //Make a number: 75 | int_to_string( g_slog_count, num_str ); 76 | len = mem_strlen( num_str ); 77 | mem_copy( g_slog_buf, num_str, len ); 78 | g_slog_buf[ len ] = ':'; 79 | g_slog_buf[ len + 1 ] = ' '; 80 | ptr2 += len + 2; 81 | g_slog_count++; 82 | 83 | //Make a string: 84 | for(;;) 85 | { 86 | if( format[ ptr ] == 0 ) break; 87 | if( format[ ptr ] == '%' ) 88 | { 89 | if( format[ ptr + 1 ] == 'd' ) 90 | { 91 | int arg = va_arg( p, int ); 92 | int_to_string( arg, num_str ); 93 | len = mem_strlen( num_str ); 94 | if( ptr2 + len >= g_slog_buf_size && g_slog_buf != g_slog_tmp_buf ) 95 | { 96 | //Resize debug buffer: 97 | g_slog_buf_size += 256; 98 | g_slog_buf = (char*)mem_resize( g_slog_buf, g_slog_buf_size ); 99 | } 100 | mem_copy( g_slog_buf + ptr2, num_str, len ); 101 | ptr2 += len; 102 | ptr++; 103 | } 104 | else 105 | if( format[ ptr + 1 ] == 's' ) 106 | { 107 | //ASCII string: 108 | char *arg2 = va_arg( p, char* ); 109 | if( arg2 ) 110 | { 111 | len = mem_strlen( arg2 ); 112 | if( len ) 113 | { 114 | if( ptr2 + len >= g_slog_buf_size && g_slog_buf != g_slog_tmp_buf ) 115 | { 116 | //Resize debug buffer: 117 | g_slog_buf_size += 256; 118 | g_slog_buf = (char*)mem_resize( g_slog_buf, g_slog_buf_size ); 119 | } 120 | mem_copy( g_slog_buf + ptr2, arg2, len ); 121 | ptr2 += len; 122 | } 123 | } 124 | ptr++; 125 | } 126 | } 127 | else 128 | { 129 | g_slog_buf[ ptr2 ] = format[ ptr ]; 130 | ptr2++; 131 | if( ptr2 >= g_slog_buf_size && g_slog_buf != g_slog_tmp_buf ) 132 | { 133 | //Resize debug buffer: 134 | g_slog_buf_size += 256; 135 | g_slog_buf = (char*)mem_resize( g_slog_buf, g_slog_buf_size ); 136 | } 137 | } 138 | ptr++; 139 | } 140 | g_slog_buf[ ptr2 ] = 0; 141 | va_end( p ); 142 | 143 | //Save result: 144 | #ifdef NONPALM 145 | FILE *f = fopen( g_slog_file, "ab" ); 146 | if( f ) 147 | { 148 | fprintf( f, "%s", g_slog_buf ); 149 | fclose( f ); 150 | } 151 | printf( "%s", g_slog_buf ); 152 | #else 153 | //PalmOS: 154 | int a; 155 | for( a = 0; a < 128; a++ ) 156 | { 157 | if( g_slog_buf[ a ] == 0 ) break; 158 | if( g_slog_buf[ a ] == 0xA ) break; 159 | if( g_slog_buf[ a ] == 0xD ) break; 160 | } 161 | WinDrawChars( " ", 80, 0, y ); 162 | WinDrawChars( g_slog_buf, a, 0, y ); 163 | y += 10; 164 | if( y >= PALMOS_Y_LIMIT ) y = 0; 165 | #endif 166 | } 167 | 168 | -------------------------------------------------------------------------------- /file/file.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | 5 | #ifdef OS_WIN 6 | #include "windows.h" 7 | #endif 8 | 9 | #ifdef OS_UNIX 10 | #include "dirent.h" //for file find 11 | #include "unistd.h" //for current dir getting 12 | #endif 13 | 14 | #define MAX_DISKS 16 15 | #define DISKNAME_SIZE 4 16 | #define MAX_DIR_LENGTH 512 17 | #define MAX_FILE_LENGTH 256 18 | extern int disks; //number of disks 19 | extern char disk_names[4*MAX_DISKS]; //disk names 20 | extern char current_dir[MAX_DIR_LENGTH]; 21 | void get_disks(void); //get info about local disks 22 | char* get_disk_name( int number ); //get name of local disk 23 | int get_current_disk(void); //get number of the current disk 24 | char* get_current_dir(void); //get current dir (without disk. example: "mydir/") 25 | 26 | #ifdef PALMOS 27 | 28 | #include "VFSMgr.h" 29 | //PalmOS functions: 30 | #define MAX_RECORDS 256 31 | #define MAX_F_POINTERS 2 32 | extern uint32_t r_size[MAX_F_POINTERS][MAX_RECORDS]; //size of each record in file 33 | extern uint32_t f_size[MAX_F_POINTERS]; //size of each file (for each file pointer) 34 | extern uint32_t cur_rec[MAX_F_POINTERS]; //current record number (for each file pointer) 35 | extern int cur_off[MAX_F_POINTERS]; //current record offset (for each file pointer) 36 | extern uint32_t cur_pnt[MAX_F_POINTERS]; //current file offset (for each file pointer) 37 | extern uint32_t recs[MAX_F_POINTERS]; //number of records (for each file pointer) 38 | extern DmOpenRef cur_db[MAX_F_POINTERS]; //current DB pointer 39 | extern LocalID ID; //local ID for DB 40 | extern uint8_t fp[MAX_F_POINTERS]; //for each file pointer: 0-free 1-working 41 | extern uint8_t *cur_rec_pnt[MAX_F_POINTERS]; 42 | extern MemHandle cur_rec_h[MAX_F_POINTERS]; 43 | extern FileRef vfs_file[ MAX_F_POINTERS ]; 44 | extern uint8_t write_flag[ MAX_F_POINTERS ]; 45 | extern uint16_t vfs_volume_numbers[8]; 46 | extern uint16_t vfs_volumes; 47 | 48 | int open_vfs(void); //Return 1 if successful. vfs_volume_number = number of first finded VFS volume (flash-card) 49 | int isBusy( DmOpenRef db, int index ); //Is record busy? 50 | void recordsBusyReset( int f ); 51 | void get_records_info( DmOpenRef db, uint16_t f_num ); 52 | void vfs2buffer( uint32_t f ); 53 | void buffer2vfs( uint32_t f ); 54 | int next_record( uint32_t f ); 55 | uint32_t get_record_rest( FILE* fpp ); 56 | 57 | #endif 58 | 59 | uint32_t file_size( const char *filename ); 60 | 61 | //FIND FILE FUNCTIONS: 62 | 63 | //type in find_struct: 64 | enum { 65 | TYPE_FILE = 0, 66 | TYPE_DIR 67 | }; 68 | 69 | struct find_struct 70 | { //structure for file searching functions 71 | const char *start_dir; //Example: "c:/mydir/" "d:/" 72 | const char *mask; //Example: "xm/mod/it" (or NULL for all files) 73 | 74 | char name[MAX_FILE_LENGTH]; //Finded file's name 75 | char type; //Finded file's type: 0 - file; 1 - dir 76 | 77 | #ifndef NONPALM 78 | uint16_t card_id; 79 | LocalID db_id; 80 | DmSearchStateType search_info; 81 | FileRef dir_ref; //VFS: reference to the start_dir 82 | uint32_t dir_iterator; //VFS: dir iterator 83 | FileInfoType file_info; //VFS: file info 84 | #endif 85 | #ifdef OS_WIN 86 | WIN32_FIND_DATA find_data; 87 | HANDLE find_handle; 88 | char win_mask[MAX_FILE_LENGTH]; //Example: "*.xm *.mod *.it" 89 | char win_start_dir[MAX_DIR_LENGTH]; //Example: "mydir\*.xm" 90 | #endif 91 | #ifdef OS_UNIX 92 | DIR *dir; 93 | struct dirent *current_file; 94 | char new_start_dir[MAX_DIR_LENGTH]; 95 | #endif 96 | }; 97 | 98 | int find_first( find_struct* ); //Return values: 0 - no files 99 | int find_next( find_struct* ); //Return values: 0 - no files 100 | void find_close( find_struct* ); 101 | 102 | void save_string( char *str, uint8_t num, const char *filename ); //save null-terminated string to the file 103 | int load_string( char *str, uint8_t num, const char *filename ); //load null-terminated string from file (or -1 if no such file) 104 | void save_int( int num, const char *filename ); 105 | int load_int( const char *filename ); // -1 if no such file 106 | 107 | enum 108 | { 109 | OPT_SCREENX = 0, 110 | OPT_SCREENY, 111 | OPT_SCREENFLIP, 112 | OPT_SOUNDBUFFER, 113 | OPT_LAST 114 | }; 115 | 116 | void read_file_with_options( const char *filename ); 117 | int get_option( int option ); //Return -1 if no such option 118 | -------------------------------------------------------------------------------- /wm/wm_directx.h: -------------------------------------------------------------------------------- 1 | /* 2 | wm_directx.h - platform-dependent module : DirectDraw (Win32) 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #pragma once 9 | 10 | #include "ddraw.h" 11 | 12 | LPDIRECTDRAW lpDD; // DirectDraw object 13 | LPDIRECTDRAWSURFACE lpDDSPrimary; // DirectDraw primary surface 14 | LPDIRECTDRAWSURFACE lpDDSBack; // DirectDraw back surface 15 | LPDIRECTDRAWSURFACE lpDDSOne; 16 | LPDIRECTDRAWCLIPPER lpClipper; 17 | HRESULT ddrval; 18 | 19 | int dd_init(void) 20 | { 21 | DDSURFACEDESC ddsd; 22 | DDSCAPS ddscaps; 23 | HRESULT ddrval; 24 | 25 | ddrval = DirectDrawCreate( NULL, &lpDD, NULL ); 26 | if( ddrval != DD_OK ) 27 | { 28 | MessageBox( hWnd,"DirectDrawCreate error","PsyTexx Error",MB_OK); 29 | return 1; 30 | } 31 | ddrval = lpDD->SetCooperativeLevel( hWnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN ); 32 | if( ddrval != DD_OK ) 33 | { 34 | MessageBox( hWnd,"SetCooperativeLevel error","PsyTexx Error",MB_OK); 35 | return 1; 36 | } 37 | ddrval = lpDD->SetDisplayMode( pscreen_x_size, pscreen_y_size, COLORBITS ); 38 | if( ddrval != DD_OK ) 39 | { 40 | MessageBox( hWnd,"SetDisplayMode error","PsyTexx Error",MB_OK); 41 | return 1; 42 | } 43 | 44 | // Create the primary surface with 1 back buffer 45 | memset( &ddsd, 0, sizeof(ddsd) ); 46 | ddsd.dwSize = sizeof( ddsd ); 47 | ddsd.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; 48 | ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_FLIP | DDSCAPS_COMPLEX; 49 | ddsd.dwBackBufferCount = 1; 50 | 51 | ddrval = lpDD->CreateSurface(&ddsd, &lpDDSPrimary, NULL); 52 | if( ddrval != DD_OK ) 53 | { 54 | switch( ddrval ) 55 | { 56 | case DDERR_UNSUPPORTEDMODE: 57 | MessageBox( hWnd,"CreateSurface DDERR_UNSUPPORTEDMODE","PsyTexx Error",MB_OK); 58 | break; 59 | case DDERR_PRIMARYSURFACEALREADYEXISTS: 60 | MessageBox( hWnd,"CreateSurface DDERR_PRIMARYSURFACEALREADYEXISTS ","PsyTexx Error",MB_OK); 61 | break; 62 | case DDERR_OUTOFVIDEOMEMORY: 63 | MessageBox( hWnd,"CreateSurface DDERR_OUTOFVIDEOMEMORY ","PsyTexx Error",MB_OK); 64 | break; 65 | case DDERR_OUTOFMEMORY: 66 | MessageBox( hWnd,"CreateSurface DDERR_OUTOFMEMORY","PsyTexx Error",MB_OK); 67 | break; 68 | case DDERR_NOZBUFFERHW: 69 | MessageBox( hWnd,"CreateSurface DDERR_NOZBUFFERHW","PsyTexx Error",MB_OK); 70 | break; 71 | case DDERR_NOOVERLAYHW: 72 | MessageBox( hWnd,"CreateSurface DDERR_NOOVERLAYHW","PsyTexx Error",MB_OK); 73 | break; 74 | case DDERR_NOMIPMAPHW: 75 | MessageBox( hWnd,"CreateSurface DDERR_NOMIPMAPHW","PsyTexx Error",MB_OK); 76 | break; 77 | case DDERR_NOEXCLUSIVEMODE: 78 | MessageBox( hWnd,"CreateSurface DDERR_NOEXCLUSIVEMODE","PsyTexx Error",MB_OK); 79 | break; 80 | case DDERR_NOEMULATION: 81 | MessageBox( hWnd,"CreateSurface DDERR_NOEMULATION","PsyTexx Error",MB_OK); 82 | break; 83 | case DDERR_NODIRECTDRAWHW: 84 | MessageBox( hWnd,"CreateSurface DDERR_NODIRECTDRAWHW","PsyTexx Error",MB_OK); 85 | break; 86 | case DDERR_NOCOOPERATIVELEVELSET: 87 | MessageBox( hWnd,"CreateSurface DDERR_NOCOOPERATIVELEVELSET","PsyTexx Error",MB_OK); 88 | break; 89 | case DDERR_NOALPHAHW: 90 | MessageBox( hWnd,"CreateSurface DDERR_NOALPHAHW","PsyTexx Error",MB_OK); 91 | break; 92 | case DDERR_INVALIDPIXELFORMAT: 93 | MessageBox( hWnd,"CreateSurface DDERR_INVALIDPIXELFORMAT","PsyTexx Error",MB_OK); 94 | break; 95 | case DDERR_INVALIDPARAMS: 96 | MessageBox( hWnd,"CreateSurface DDERR_INVALIDPARAMS","PsyTexx Error",MB_OK); 97 | break; 98 | case DDERR_INVALIDOBJECT: 99 | MessageBox( hWnd,"CreateSurface DDERR_INVALIDOBJECT","PsyTexx Error",MB_OK); 100 | break; 101 | case DDERR_INVALIDCAPS: 102 | MessageBox( hWnd,"CreateSurface DDERR_INVALIDCAPS","PsyTexx Error",MB_OK); 103 | break; 104 | case DDERR_INCOMPATIBLEPRIMARY: 105 | MessageBox( hWnd,"CreateSurface DDERR_INCOMPATIBLEPRIMARY","PsyTexx Error",MB_OK); 106 | break; 107 | } 108 | return 1; 109 | } 110 | 111 | ddscaps.dwCaps = DDSCAPS_BACKBUFFER; 112 | ddrval = lpDDSPrimary->GetAttachedSurface(&ddscaps, &lpDDSBack); 113 | if( ddrval != DD_OK ) 114 | { 115 | MessageBox( hWnd,"GetAttachedSurface error","PsyTexx Error",MB_OK); 116 | return 1; 117 | } 118 | 119 | current_wm->lpDDSBack = lpDDSBack; 120 | current_wm->lpDDSPrimary = lpDDSPrimary; 121 | 122 | return 0; 123 | } 124 | 125 | int dd_close() 126 | { 127 | if(lpDD != NULL) 128 | { 129 | if(lpDDSPrimary != NULL) 130 | { 131 | lpDDSPrimary->Release(); 132 | lpDDSPrimary = NULL; 133 | } 134 | lpDD->Release(); 135 | lpDD = NULL; 136 | } 137 | return 0; 138 | } 139 | -------------------------------------------------------------------------------- /psytexx/win_psyconfig.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | win_psyconfig.cpp - config window 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "win_main.h" 9 | #include "win_button.h" 10 | #include "win_psyconfig.h" 11 | #include "win_scrollbar.h" 12 | #include "win_psymenu.h" 13 | #include "win_text.h" 14 | #include "../xm/xm.h" 15 | 16 | int button_cclose_handler( void *user_data, int win, window_manager *wm ) 17 | { 18 | config_data *data = (config_data*)user_data; 19 | send_event( data->this_window, EVT_HIDE, 0, 0, 0, 0, MODE_CHILDS, wm ); 20 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 21 | 22 | window *mwin = wm->windows[ win_menu ]; 23 | menu_data *mdata = (menu_data*)mwin->data; 24 | mdata->config_status = 0; 25 | 26 | return 0; 27 | } 28 | 29 | int scroll_vol_handler( void *user_data, int win, window_manager *wm ) 30 | { 31 | config_data *data = (config_data*)user_data; 32 | window *swin = wm->windows[ data->scroll_volume ]; 33 | scrollbar_data *sdata = (scrollbar_data*)swin->data; 34 | 35 | int vol = sdata->cur; 36 | xm_set_volume( vol, &xm ); 37 | 38 | data->volume_changed = vol; 39 | 40 | return 0; 41 | } 42 | 43 | int config_handler(wm_event *evt, window_manager *wm) 44 | { 45 | window *win = wm->windows[ evt->event_win ]; //Our window 46 | config_data *data = (config_data*)win->data; 47 | int text; 48 | int old_vol; 49 | int scroll_size; 50 | 51 | switch( evt->event_type ) 52 | { 53 | case EVT_AFTERCREATE: 54 | win->data = mem_new( HEAP_DYNAMIC, sizeof(config_data), "config data" ); 55 | //Init data: 56 | data = (config_data*)win->data; 57 | 58 | data->this_window = evt->event_win; 59 | 60 | data->volume_changed = -1; 61 | 62 | data->button_close = create_window( "cclose", 1, win->y_size-3, 6, 2, wm->colors[6], 1, evt->event_win, &button_handler, wm ); 63 | set_window_string_controls( data->button_close, "1", "100%-1", "7", "100%-3", wm ); 64 | button_set_handler( &button_cclose_handler, (void*)data, data->button_close, wm ); 65 | button_set_name( "CLOSE", data->button_close, wm ); 66 | 67 | scroll_size = 38; 68 | NEW_SCROLL_TYPE = 1; 69 | data->scroll_volume = create_window( "volume", 1, win->y_size-3-3, scroll_size, 2, wm->colors[6], 1, evt->event_win, &scrollbar_handler, wm ); 70 | set_window_string_controls( data->scroll_volume, "1", "100%-4", "100%-1 <39", "100%-6", wm ); 71 | scrollbar_set_handler( &scroll_vol_handler, (void*)data, data->scroll_volume, wm ); 72 | scrollbar_set_parameters( data->scroll_volume, 1, 128, 32, 20, wm ); 73 | //Check for previous saved volume: 74 | old_vol = load_int( PROP_VOLUME ); 75 | if( old_vol != -1 ) 76 | { 77 | xm_set_volume( old_vol, &xm ); 78 | scrollbar_set_cur_value( data->scroll_volume, old_vol, wm ); 79 | } 80 | 81 | text = create_window( "textvolume", 1, win->y_size-3-3-2, 8, 1, win->color, 1, evt->event_win, &text_handler, wm ); 82 | set_window_string_controls( text, "1", "100%-7", "11", "100%-8", wm ); 83 | text_set_text( text, "VOLUME:", wm ); 84 | text_set_readonly( text, 1, wm ); 85 | 86 | text = create_window( "version2", 1, 1, 32, 1, win->color, 1, evt->event_win, &text_handler, wm ); 87 | text_set_text( text, PSYTEXX_VERSION, wm ); 88 | text_set_readonly( text, 1, wm ); 89 | text = create_window( "date2", 1, 2, 32, 1, win->color, 1, evt->event_win, &text_handler, wm ); 90 | text_set_text( text, PSYTEXX_DATE, wm ); 91 | text_set_readonly( text, 1, wm ); 92 | 93 | data->volume_changed = -1; 94 | break; 95 | 96 | case EVT_BEFORECLOSE: 97 | if( data->volume_changed ) save_int( data->volume_changed, PROP_VOLUME ); 98 | if( win->data ) mem_free( win->data ); 99 | break; 100 | case EVT_SHOW: 101 | //Show window: 102 | win->visible = 1; //Make it visible 103 | send_event(evt->event_win, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm); //Send DRAW event to all childs 104 | break; 105 | case EVT_HIDE: 106 | win->visible = 0; 107 | break; 108 | case EVT_DRAW: 109 | //Draw window (if it's visible) 110 | if( win->visible ) 111 | { 112 | draw_window_touch_area( evt->event_win, wm ); 113 | draw_window_box(evt->event_win,wm); //draw window box 114 | draw_vert_line( evt->event_win, win->x_size * wm->char_x - 1, 0, win->y_size * wm->char_y, get_color( 0, 0, 0 ), 2, wm ); 115 | } 116 | break; 117 | case EVT_REDRAW: 118 | //Redraw window (if it's visible) 119 | if( win->visible ) 120 | { 121 | draw_window_box(evt->event_win,wm); //draw window box 122 | draw_vert_line( evt->event_win, win->x_size * wm->char_x - 1, 0, win->y_size * wm->char_y, get_color( 0, 0, 0 ), 2, wm ); 123 | } 124 | break; 125 | } 126 | return 0; 127 | } 128 | -------------------------------------------------------------------------------- /psytexx/win_button.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | win_button.cpp - button handler 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "win_main.h" 9 | #include "win_button.h" 10 | #include "../time/time.h" 11 | 12 | #ifndef TEXTMODE 13 | char txt_up[4] = { 1, 0 }; 14 | char txt_down[4] = { 2, 0 }; 15 | char txt_left[4] = { 3, 0 }; 16 | char txt_right[4] = { 4, 0 }; 17 | #else 18 | char txt_up[4] = { '^', 0 }; //{ '/', 0x5C, 0 }; 19 | char txt_down[4] = { 'v', 0 }; //{ 0x5C, '/', 0 }; 20 | char txt_left[4] = { '<', 0 }; 21 | char txt_right[4] = { '>', 0 }; 22 | #endif 23 | 24 | void button_set_color( COLOR color, int win_num, window_manager *wm ) 25 | { 26 | window *win = wm->windows[ win_num ]; //Our window 27 | button_data *data = (button_data*)win->data; 28 | data->color = color; 29 | } 30 | 31 | void button_set_name( const char* name, int win_num, window_manager *wm ) 32 | { 33 | window *win = wm->windows[ win_num ]; //Our window 34 | button_data *data = (button_data*)win->data; 35 | int len = 0; 36 | 37 | data->name = name; 38 | for(;;) 39 | { 40 | if( name[len] == 0 ) break; 41 | len++; 42 | } 43 | 44 | data->len = len; 45 | } 46 | 47 | void button_set_handler( int (*handler)(void*,int,window_manager*), void *user_data, int win_num, window_manager *wm ) 48 | { 49 | window *win = wm->windows[ win_num ]; //Our window 50 | button_data *data = (button_data*)win->data; 51 | 52 | data->handler = (int (*)(void*,int,void*))handler; 53 | data->user_data = user_data; 54 | } 55 | 56 | void button_set_autorepeat( char autorepeat, int win_num, window_manager* wm ) 57 | { 58 | window *win = wm->windows[ win_num ]; //Our window 59 | button_data *data = (button_data*)win->data; 60 | data->autorepeat = autorepeat; 61 | } 62 | 63 | void button_autorepeat_handler( void *bdata, window_manager *wm ) 64 | { 65 | button_data *data = (button_data*)bdata; 66 | 67 | data->autorepeat_pressed = 1; 68 | if( data->handler ) data->handler( data->user_data, data->this_window, (void*)wm ); 69 | wm_timer_set( 80, &button_autorepeat_handler, (void*)data, wm ); //Set it again 70 | } 71 | 72 | void button_handler_draw(wm_event *evt, window_manager *wm) 73 | { 74 | window *win = wm->windows[ evt->event_win ]; //Our window 75 | button_data *data = (button_data*)win->data; 76 | 77 | if( win->visible ) 78 | { 79 | data->x = ( (win->x_size - data->len) * wm->char_x ) >> 1; 80 | data->y = ( (win->y_size - 1) * wm->char_y ) >> 1; 81 | 82 | if( evt->event_type == EVT_DRAW ) 83 | { 84 | //draw_window_touch_area( evt->event_win, wm ); 85 | draw_touch_box( win->parent_win, win->x, win->y, win->x_size, win->y_size, evt->event_win, wm ); 86 | } 87 | 88 | win->color = data->color; 89 | int offset = 0; 90 | #ifdef TEXTMODE 91 | if( data->pressed ) 92 | win->color = get_color( 200, 200, 200 ); 93 | #else 94 | if( data->pressed ) 95 | { 96 | win->color = blend( data->color, 0, 64 ); 97 | offset = 1; 98 | } 99 | #endif 100 | draw_window_box( evt->event_win, wm ); 101 | if( data->name ) 102 | draw_string( evt->event_win, data->x + offset, data->y + offset, win->color, data->name, wm ); 103 | } 104 | } 105 | 106 | int button_handler(wm_event *evt, window_manager *wm) 107 | { 108 | window *win = wm->windows[ evt->event_win ]; //Our window 109 | button_data *data = (button_data*)win->data; 110 | 111 | switch( evt->event_type ) 112 | { 113 | case EVT_AFTERCREATE: 114 | win->data = mem_new( HEAP_DYNAMIC, sizeof(button_data), "button data" ); 115 | //Init data: 116 | data = (button_data*)win->data; 117 | data->this_window = evt->event_win; 118 | data->name = 0; 119 | data->color = win->color; 120 | data->pressed = 0; 121 | data->autorepeat = 0; 122 | data->autorepeat_pressed = 0; 123 | data->handler = 0; 124 | data->user_data = 0; 125 | break; 126 | case EVT_BEFORECLOSE: 127 | if( win->data ) mem_free( win->data ); 128 | break; 129 | case EVT_SHOW: 130 | //Show window: 131 | win->visible = 1; //Make it visible 132 | send_event(evt->event_win, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm); //Send DRAW event to all childs 133 | break; 134 | case EVT_HIDE: 135 | win->visible = 0; 136 | break; 137 | case EVT_DRAW: 138 | case EVT_REDRAW: 139 | button_handler_draw( evt, wm ); 140 | break; 141 | case EVT_BUTTONDOWN: 142 | if( evt->button & BUTTON_LEFT ) 143 | { 144 | data->pressed = 1; 145 | button_handler_draw( evt, wm ); 146 | 147 | if( data->autorepeat ) 148 | { 149 | wm_timer_set( 700, &button_autorepeat_handler, (void*)data, wm ); 150 | } 151 | } 152 | break; 153 | case EVT_BUTTONUP: 154 | if( evt->button & BUTTON_LEFT && data->pressed ) 155 | { 156 | data->pressed = 0; 157 | button_handler_draw( evt, wm ); 158 | 159 | if( evt->x < win->x_size * wm->char_x && evt->y < win->y_size * wm->char_y ) 160 | { 161 | if( evt->x >= 0 && evt->y >= 0 && data->autorepeat_pressed == 0 ) 162 | { 163 | //User defined handler: 164 | if( data->handler ) data->handler( data->user_data, evt->event_win, (void*)wm ); 165 | } 166 | } 167 | 168 | if( data->autorepeat ) 169 | { 170 | data->autorepeat_pressed = 0; 171 | wm_timer_close( wm ); 172 | } 173 | } 174 | break; 175 | } 176 | return 0; 177 | } 178 | -------------------------------------------------------------------------------- /psytexx/win_popup.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | win_popup.cpp - dynamic menu 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "win_main.h" 9 | #include "win_popup.h" 10 | 11 | int popup_opened = 0; 12 | 13 | int start_popup_blocked( 14 | const char *text, 15 | int x, int y, 16 | window_manager *wm ) 17 | { 18 | if( popup_opened ) return -1; 19 | window *win = wm->windows[ win_popup ]; //Our window 20 | popup_data *data = (popup_data*)win->data; 21 | 22 | send_event( win_popup, EVT_SHOW, 0, 0, 0, 0, MODE_CHILDS, wm ); 23 | //Set focus to this window: 24 | data->old_focus_window = wm->mouse_win; 25 | wm->mouse_win = win_popup; 26 | 27 | popup_opened = 1; 28 | data->result = -1; 29 | data->selected = -1; 30 | data->text = text; 31 | 32 | //Set window position: 33 | x /= wm->char_x; 34 | y /= wm->char_y; 35 | 36 | //Set window size: 37 | int lines = 1; 38 | int max_x_size = 1; 39 | int cur_x_size = 0; 40 | for( int i = 0; i < mem_strlen( text ); i++ ) 41 | { 42 | if( text[ i ] == 0xA ) { lines++; cur_x_size = 0; } 43 | if( text[ i ] != 0xA && text[ i ] != 0xD ) 44 | { 45 | cur_x_size++; 46 | if( cur_x_size > max_x_size ) max_x_size = cur_x_size; 47 | } 48 | } 49 | win->y_size = lines; 50 | win->x_size = max_x_size + 1; 51 | 52 | //Correct position: 53 | if( y + win->y_size >= wm->screen_y ) y = wm->screen_y - win->y_size; 54 | if( x + win->x_size > wm->screen_x ) x = wm->screen_x - win->x_size; 55 | move_window( win_popup, x, y, wm ); 56 | 57 | while( data->result == -1 ) 58 | { 59 | if( wm->events_count ) 60 | { 61 | int ev_num; 62 | for( ev_num = 0; ev_num < wm->events_count; ev_num++ ) 63 | { 64 | wm_event *evt = wm->events[ ( wm->event_pnt + ev_num ) & MAX_EVENT ]; 65 | if( evt ) 66 | if( evt->event_win ) 67 | if( evt->event_type == EVT_BUTTONDOWN && ( evt->button & 3 ) ) 68 | if( evt->event_win != win_popup ) 69 | { 70 | //Was a click on another window: 71 | send_event( win_popup, EVT_HIDE, 0, 0, 0, 0, MODE_CHILDS, wm ); 72 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 73 | //wm->mouse_win = data->old_focus_window; 74 | data->result = -2; 75 | //break; 76 | } 77 | } 78 | } 79 | event_loop( wm, 0 ); 80 | } 81 | 82 | popup_opened = 0; 83 | return data->result; 84 | } 85 | 86 | int popup_handler( wm_event *evt, window_manager *wm ) 87 | { 88 | window *win = wm->windows[ evt->event_win ]; //Our window 89 | popup_data *data = (popup_data*)win->data; 90 | int handled = 0; 91 | 92 | switch( evt->event_type ) 93 | { 94 | case EVT_AFTERCREATE: 95 | win->data = mem_new( HEAP_DYNAMIC, sizeof(popup_data), "popup data" ); 96 | //Init data: 97 | data = (popup_data*)win->data; 98 | data->this_window = evt->event_win; 99 | data->result = -1; 100 | data->selected = -1; 101 | data->text = ""; 102 | break; 103 | 104 | case EVT_BEFORECLOSE: 105 | if( win->data ) mem_free( win->data ); 106 | break; 107 | 108 | case EVT_SHOW: 109 | //Show window: 110 | win->visible = 1; //Make it visible 111 | send_event(evt->event_win, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm); //Send DRAW event to all childs 112 | break; 113 | 114 | case EVT_HIDE: 115 | win->visible = 0; 116 | break; 117 | 118 | case EVT_DRAW: 119 | //Draw/redraw window (if it's visible) 120 | if( win->visible ) draw_window_touch_area( evt->event_win, wm ); 121 | case EVT_REDRAW: 122 | if( win->visible ) 123 | { 124 | pdraw_box( evt->event_win, 0, 0, win->x_size * wm->char_x, win->y_size * wm->char_y, blend( win->color, 0, 20 ), wm ); 125 | //Show selection: 126 | if( data->selected >= 0 ) 127 | { 128 | pdraw_box( evt->event_win, 0, data->selected * wm->char_y, win->x_size * wm->char_x, wm->char_y, get_color( 255, 160, 90 ), wm ); 129 | } 130 | //Draw text: 131 | draw_string( evt->event_win, wm->char_x / 2, 0, 1, data->text, wm ); 132 | } 133 | break; 134 | 135 | case EVT_BUTTONDOWN: 136 | handled = 1; 137 | if( evt->button >> 3 ) 138 | { 139 | switch( evt->button >> 3 ) 140 | { 141 | case KEY_ESCAPE: 142 | send_event( data->this_window, EVT_HIDE, 0, 0, 0, 0, MODE_CHILDS, wm ); 143 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 144 | wm->mouse_win = data->old_focus_window; 145 | data->result = -2; 146 | handled = 1; 147 | break; 148 | } 149 | } 150 | if( evt->button & BUTTON_LEFT ) 151 | { 152 | data->selected = evt->y / wm->char_y; 153 | send_event( evt->event_win, EVT_REDRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 154 | } 155 | break; 156 | 157 | case EVT_BUTTONUP: 158 | handled = 1; 159 | if( evt->button & BUTTON_LEFT ) 160 | { 161 | if( data->selected >= 0 && data->selected < win->y_size ) 162 | { 163 | send_event( data->this_window, EVT_HIDE, 0, 0, 0, 0, MODE_CHILDS, wm ); 164 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 165 | data->result = data->selected; 166 | } 167 | } 168 | break; 169 | 170 | case EVT_MOUSEMOVE: 171 | handled = 1; 172 | if( evt->button & BUTTON_LEFT ) 173 | { 174 | data->selected = evt->y / wm->char_y; 175 | send_event( evt->event_win, EVT_REDRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 176 | } 177 | break; 178 | } 179 | return handled; 180 | } 181 | -------------------------------------------------------------------------------- /xm/xm_channels.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | xm_channels.cpp - functions for working with channels 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "xm.h" 9 | #include "../log/log.h" 10 | #include "../memory/memory.h" 11 | 12 | #define GET_FREQ(per) ( linear_tab[ per % 768 ] >> (per/768) ) 13 | #define GET_DELTA(f) ( ( ( f << 10 ) / xm->freq ) << ( XM_PREC - 10 ) ) 14 | 15 | void clear_channels(xm_struct *xm) 16 | { 17 | int a; 18 | 19 | for( a = 0; a < MAX_REAL_CHANNELS; a++ ) 20 | { 21 | if( xm->channels[ a ] != 0 ) 22 | { 23 | mem_free( (void*) xm->channels[ a ] ); 24 | xm->channels[ a ] = 0; 25 | } 26 | } 27 | } 28 | 29 | void new_channels( int number_of_channels, xm_struct *xm ) 30 | { 31 | int a; 32 | channel *c; 33 | 34 | xm->chans = number_of_channels; 35 | 36 | for( a = 0; a < number_of_channels; a++ ) 37 | { 38 | if( xm->channels[ a ] == 0 ) 39 | { 40 | c = (channel*) mem_new( 0, sizeof(channel), "channel" ); 41 | mem_set( c, sizeof(channel), 0 ); 42 | c->enable = 1; 43 | c->recordable = 1; 44 | 45 | xm->channels[ a ] = c; 46 | } 47 | } 48 | } 49 | 50 | void clean_channels( xm_struct *xm ) 51 | { 52 | int number_of_channels = xm->chans; 53 | int a; 54 | channel* c; 55 | 56 | for( a = 0; a < number_of_channels; a++ ) 57 | { 58 | if( xm->channels[ a ] != 0 ) 59 | { 60 | c = xm->channels[ a ]; 61 | int enable = c->enable; 62 | mem_set( c, sizeof(channel), 0 ); 63 | c->enable = enable; 64 | c->recordable = 1; 65 | } 66 | } 67 | } 68 | 69 | #ifndef XM_PLAYER 70 | 71 | int play_note( int note_num, int instr_num, int pressure, xm_struct *xm ) 72 | { 73 | int cur_channel = xm->cur_channel; 74 | module *song = xm->song; 75 | int channels = song->channels * SUBCHANNELS; 76 | 77 | if( cur_channel >= channels ) cur_channel = 0; 78 | 79 | //Searching for the empty channel (only in PLAY mode): 80 | int c = 0, c2 = 0; 81 | channel *ch; 82 | if( xm->status ) 83 | { 84 | for( c = 0; c < channels; c += SUBCHANNELS ) 85 | { 86 | ch = xm->channels[ c ]; 87 | if( ch ) 88 | if( ch->smp == 0 && ch->enable && xm->channel_busy[ c ] == 0 ) { cur_channel = c; break; } 89 | } 90 | } 91 | 92 | if( c == channels || xm->status == 0 ) //If there is no empty channel: 93 | { 94 | //Searching for the first active channel: 95 | for( c = 1; c < channels; c += SUBCHANNELS ) 96 | { 97 | c2 = cur_channel + c; if( c2 >= channels ) c2 -= channels; 98 | ch = xm->channels[ c2 ]; 99 | if( ch ) 100 | if( ch->enable && !ch->sustain && xm->channel_busy[ c ] == 0 ) { cur_channel = c2; break; } 101 | } 102 | if( c == channels ) return -1; //No active channels :( 103 | } 104 | 105 | //Save current channel number: 106 | xm->cur_channel = cur_channel; 107 | 108 | //Play note: 109 | instrument *ins = song->instruments[ instr_num ]; 110 | if( ins ) 111 | { 112 | int smp_num = ins->sample_number[ note_num ]; 113 | sample *smp; 114 | if( ins->samples_num && smp_num < ins->samples_num ) 115 | smp = ins->samples[ smp_num ]; 116 | else 117 | smp = 0; 118 | if( smp ) 119 | { 120 | if( smp->data && smp->length ) 121 | { 122 | channel *ch2 = &xm->ch_buf[ xm->ch_write_ptr & ( CHANNELS_IN_BUFFER - 1 ) ]; 123 | xm->ch_channels[ xm->ch_write_ptr & ( CHANNELS_IN_BUFFER - 1 ) ] = cur_channel; 124 | 125 | int *linear_tab = (int*)xm->linear_tab; 126 | ch2->smp = 0; 127 | 128 | ch2->pan = smp->panning; 129 | ch2->vol = ( (int)smp->volume * pressure ) >> 10; 130 | //Retring. envelope: 131 | ch2->v_pos = 0; 132 | ch2->p_pos = 0; 133 | ch2->sustain = 1; 134 | ch2->fadeout = 65536; 135 | ch2->vib_pos = 0; 136 | ch2->cur_frame = 0; 137 | ch2->env_start = 1; 138 | //Retrig. sample: 139 | ch2->ticks = 0; 140 | ch2->back = 0; 141 | //Set note: 142 | note_num += smp->relative_note; 143 | note_num += ins->relative_note; 144 | note_num += xm->octave * 12; 145 | if( note_num > 119 ) note_num = 119; 146 | if( note_num < 0 ) note_num = 0; 147 | int period = 7680 - (note_num*64) - (smp->finetune>>1) - (ins->finetune>>1); 148 | ch2->p_period = ch2->period = period; 149 | ch2->new_period = period; 150 | int freq = GET_FREQ(period); 151 | ch2->delta = GET_DELTA(freq); 152 | ch2->delta_p = ch2->delta & ( ( 1 << XM_PREC ) - 1 ); 153 | ch2->delta >>= XM_PREC; 154 | //Set sample: 155 | ch2->ins_num = instr_num; 156 | ch2->ins = ins; 157 | ch2->smp = smp; 158 | 159 | int new_wr = ( xm->ch_write_ptr + 1 ) & ( CHANNELS_IN_BUFFER - 1 ); 160 | xm->ch_write_ptr = new_wr; 161 | 162 | xm->channel_busy[ cur_channel ] = 1; 163 | } 164 | } 165 | } 166 | 167 | return cur_channel; 168 | } 169 | 170 | void stop_note( int channel_num, xm_struct *xm ) 171 | { 172 | channel *ch2 = &xm->ch_buf[ xm->ch_write_ptr & ( CHANNELS_IN_BUFFER - 1 ) ]; 173 | xm->ch_channels[ xm->ch_write_ptr & ( CHANNELS_IN_BUFFER - 1 ) ] = channel_num; 174 | 175 | ch2->ins_num = -1; 176 | 177 | int new_wr = ( xm->ch_write_ptr + 1 ) & ( CHANNELS_IN_BUFFER - 1 ); 178 | xm->ch_write_ptr = new_wr; 179 | 180 | /* 181 | channel *ch = xm->channels[ channel_num ]; 182 | if( ch ) 183 | { 184 | ch->sustain = 0; 185 | instrument *ins = ch->ins; 186 | if( ins ) 187 | if( !(ins->volume_type & 1) ) ch->smp = 0; //No envelope 188 | xm->channel_busy[ channel_num ] = 0; 189 | } 190 | */ 191 | } 192 | 193 | #endif 194 | -------------------------------------------------------------------------------- /psytexx/win_psytable.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | #include "../core/core.h" 4 | #include "../wm/wm.h" 5 | 6 | //NEW TABLE: ======================= 7 | //(SET IT UP BEFORE WINDOW CREATION) 8 | extern int table_type; 9 | extern int CREATE_TABLE_WITH_EDIT_BUTTON; 10 | //================================== 11 | 12 | enum field_type 13 | { 14 | FIELD_NONE = 0, 15 | FIELD_CHANNEL, 16 | FIELD_PATTERN_NUM, 17 | FIELD_PATTERNTABLE_POS, 18 | FIELD_NOTE, 19 | FIELD_PATTERN_POS, 20 | FIELD_LAST 21 | }; 22 | 23 | enum element_type 24 | { 25 | ELEMENT_NONE = 0, 26 | ELEMENT_PATTERN_NUM, 27 | ELEMENT_NOTE, 28 | ELEMENT_INSTRUMENT, 29 | ELEMENT_VOLUME, 30 | ELEMENT_EFFECT, 31 | ELEMENT_PARAMETER, 32 | ELEMENT_DIVIDER, 33 | ELEMENT_LAST 34 | }; 35 | 36 | extern uint8_t element_xsize[ ELEMENT_LAST ]; 37 | 38 | #define MAX_ELEMENTS 8 39 | #define TYPE_VSCROLL 1 40 | #define TYPE_HSCROLL 2 41 | #define TYPE_DIVIDERS 4 42 | #define HALIGN 1 43 | #define VALIGN 2 44 | 45 | 46 | //TABLE: 47 | // 48 | //####################### 49 | //# # 50 | //# # H 51 | //# # 52 | //####################### 53 | //# # | | | 54 | //# # | | | 55 | //# #------------------ 56 | //# V # | | | 57 | //# # | CELLS | 58 | //# #------------------ 59 | //# # | | | 60 | // 61 | //H - horisontal field 62 | //V - vertical field 63 | // 64 | //One cell = array of elements 65 | 66 | //INTERNAL STRUCTURES: 67 | 68 | struct table_data 69 | { 70 | int this_window; 71 | 72 | int h_scroll; //HScroll window 73 | int v_scroll; //VScroll window 74 | 75 | int type; //Table type: TYPE_xxx 76 | int scroll_size; //Size of scrollbars 77 | 78 | int vertical_field; //check the field_type enum 79 | int horisontal_field; //check the field_type enum 80 | int vertical_field_size; 81 | int horisontal_field_size; 82 | 83 | int elements_align; //HALIGN or VALIGN (horisontal or vertical) 84 | int elements[ MAX_ELEMENTS ]; //One cell of the table (visible) 85 | int elements_num; //Number of elements in one cell 86 | int full_elements[ MAX_ELEMENTS ]; //Full cell of the table 87 | int full_elements_num; //Number of elements in full cell 88 | int cell_xsize; 89 | int cell_ysize; 90 | 91 | int xstart; //Start position in horisontal field 92 | int ystart; //Start position in vertical field 93 | int v_offset; //Offset in vertical field 94 | int h_offset; //Offset in horisontal field 95 | int v_cells; //Number of vertical visible cells in current window 96 | int h_cells; //Number of horisontal visible cells in current window 97 | 98 | int current_cell; //Number of current cell 99 | int current_element; //Number of current element 100 | int current_offset; //Number of current element offset 101 | 102 | uint8_t scroll_flag; 103 | 104 | //Selection: 105 | int selection; //0 - finished; 1 - user selecting new region 106 | int sel_x; 107 | int sel_y; 108 | int sel_xsize; 109 | int sel_ysize; 110 | 111 | int fullscreen_button; 112 | int edit_button; 113 | uint8_t fullscreen; //1 - fullscreen button enabled 114 | uint8_t fullscreen_status; //1 - maximized 115 | int change_view_button; 116 | uint8_t change_view; //1 - "change view" button enabled 117 | uint8_t change_view_status; 118 | const char *old_y_string; 119 | 120 | //Tracker specific variables: 121 | int record_status; //Record mode ON/OFF 122 | COLOR record_color; 123 | 124 | void *copy_buffer[3]; //Full table (pattern) / Block / Column (channel) 125 | int copy_buffer_xsize[3]; 126 | int copy_buffer_ysize[3]; 127 | }; 128 | 129 | //FUNCTIONS: 130 | 131 | int table_field_values( int field_type ); //Get number of field values 132 | char* table_field_text( int field_type, int value, window_manager* ); //Convert field value to text 133 | int table_field_value( int field_type ); //Get current (real) field value 134 | void table_field_set_value( int field_type, int new_value ); 135 | int table_get_element_value( table_data *data, int element_type ); 136 | int table_set_element_value( table_data *data, int element_type, int element_value ); 137 | void table_cell_draw( table_data *data, 138 | int win_num, 139 | int x, 140 | int y, 141 | int highlight, 142 | int current_cell_flag, 143 | window_manager* ); 144 | void table_draw_record_status( int win_num, char, window_manager* ); 145 | void table_draw( int win_num, window_manager* ); 146 | void table_new( int win_num, 147 | int type, 148 | int vertical_field, 149 | int horisontal_field, 150 | int elements_align, 151 | int elements_num, 152 | window_manager*, 153 | ... ); 154 | void table_full_cell( int win_num, int elements_num, window_manager*, ... ); 155 | void table_set_type( int type_flags, int win_num, window_manager* ); 156 | void table_set_fullscreen( int fullscreen, int win_num, window_manager* ); 157 | void table_set_change_view( int change_view, int win_num, window_manager* ); 158 | void handle_key( uint key, int win_num, window_manager* ); 159 | 160 | //HANDLERS: 161 | 162 | int change_view_button_handler( void* user_data, int button_win, window_manager* wm ); 163 | int fullscreen_button_handler( void* user_data, int button_win, window_manager* wm ); 164 | int v_scroll_handler(void *user_data, int scroll_win, window_manager*); 165 | int h_scroll_handler(void *user_data, int scroll_win, window_manager*); 166 | 167 | //WINDOW HANDLERS: 168 | 169 | int table_handler( wm_event*, window_manager* ); 170 | -------------------------------------------------------------------------------- /psytexx/win_psypatterntab.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | win_psypatterntab.cpp - pattern functions (add, del, inc, dec ...) 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "win_psypattern.h" 9 | #include "win_psypatterntab.h" 10 | #include "win_button.h" 11 | #include "win_text.h" 12 | #include "win_main.h" 13 | #include "../xm/xm.h" 14 | 15 | int button_inc_handler(void *user_data, int text_win, window_manager *wm) 16 | { 17 | patterntab_data *data = (patterntab_data*)user_data; 18 | module *song = xm.song; 19 | uint8_t patnum = song->patterntable[ xm.tablepos ]; 20 | patnum++; 21 | if( patnum >= song->patterns_num ) 22 | { //Increment number of patterns in the song: 23 | song->patterns_num = (uint16_t)patnum + 1; 24 | } 25 | pattern *pat = song->patterns[ patnum ]; 26 | int need_new_pat = 0; 27 | if( pat == 0 ) 28 | { 29 | need_new_pat = 1; 30 | } 31 | else 32 | { 33 | if( pat->pattern_data == 0 ) 34 | { 35 | need_new_pat = 1; 36 | mem_off(); 37 | clear_pattern( patnum, &xm ); 38 | mem_on(); 39 | } 40 | } 41 | if( need_new_pat ) 42 | { //Create new pattern: 43 | mem_off(); 44 | new_pattern( patnum, 64, song->channels, &xm ); 45 | clean_pattern( patnum, &xm ); 46 | mem_on(); 47 | } 48 | //Save pattern num: 49 | song->patterntable[ xm.tablepos ] = patnum; 50 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); //Redraw screen 51 | return 0; 52 | } 53 | 54 | int button_dec_handler(void *user_data, int text_win, window_manager *wm) 55 | { 56 | patterntab_data *data = (patterntab_data*)user_data; 57 | module *song = xm.song; 58 | uint8_t patnum = song->patterntable[ xm.tablepos ]; 59 | patnum--; 60 | if( patnum >= song->patterns_num ) 61 | { //Increment number of patterns in the song: 62 | song->patterns_num = (uint16_t)patnum + 1; 63 | } 64 | pattern *pat = song->patterns[ patnum ]; 65 | int need_new_pat = 0; 66 | if( pat == 0 ) 67 | { 68 | need_new_pat = 1; 69 | } 70 | else 71 | { 72 | if( pat->pattern_data == 0 ) 73 | { 74 | need_new_pat = 1; 75 | mem_off(); 76 | clear_pattern( patnum, &xm ); 77 | mem_on(); 78 | } 79 | } 80 | if( need_new_pat ) 81 | { //Create new pattern: 82 | mem_off(); 83 | new_pattern( patnum, 64, song->channels, &xm ); 84 | clean_pattern( patnum, &xm ); 85 | mem_on(); 86 | } 87 | //Save pattern num: 88 | song->patterntable[ xm.tablepos ] = patnum; 89 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); //Redraw screen 90 | return 0; 91 | } 92 | 93 | int button_ins_handler(void *user_data, int text_win, window_manager *wm) 94 | { 95 | patterntab_data *data = (patterntab_data*)user_data; 96 | module *song = xm.song; 97 | uint16_t len = song->length; 98 | len++; 99 | if( len > 256 ) len = 256; 100 | for( int a = len - 1; a > xm.tablepos; a-- ) 101 | { 102 | song->patterntable[ a ] = song->patterntable[ a - 1 ]; 103 | } 104 | song->length = len; 105 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); //Redraw screen 106 | return 0; 107 | } 108 | 109 | int button_del_handler2(void *user_data, int text_win, window_manager *wm) 110 | { 111 | patterntab_data *data = (patterntab_data*)user_data; 112 | module *song = xm.song; 113 | uint16_t len = song->length; 114 | if( len > 1 ) 115 | { 116 | for( int a = xm.tablepos; a < len - 1; a++ ) 117 | { 118 | song->patterntable[ a ] = song->patterntable[ a + 1 ]; 119 | } 120 | len--; 121 | song->length = len; 122 | } 123 | if( xm.tablepos >= len ) 124 | xm.tablepos = (int)len - 1; 125 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); //Redraw screen 126 | return 0; 127 | } 128 | 129 | int patterntab_handler(wm_event *evt, window_manager *wm) 130 | { 131 | window *win = wm->windows[ evt->event_win ]; //Our window 132 | patterntab_data *data = (patterntab_data*)win->data; 133 | 134 | switch( evt->event_type ) 135 | { 136 | case EVT_AFTERCREATE: 137 | win->data = mem_new( HEAP_DYNAMIC, sizeof(patterntab_data), "pattern control" ); 138 | 139 | //Init data: 140 | data = (patterntab_data*)win->data; 141 | 142 | data->this_window = evt->event_win; 143 | 144 | //Create buttons: 145 | data->button_dec = create_window( "dec", win->x_size>>1, 3, win->x_size>>1, 2, wm->colors[13], 1, evt->event_win, &button_handler, wm ); 146 | set_window_string_controls( data->button_dec, "50%", "2", "100%", "4", wm ); 147 | button_set_name( "-", data->button_dec, wm ); 148 | button_set_handler( &button_dec_handler, data, data->button_dec, wm ); 149 | data->button_inc = create_window( "inc", win->x_size>>1, 1, win->x_size>>1, 2, wm->colors[13], 1, evt->event_win, &button_handler, wm ); 150 | set_window_string_controls( data->button_inc, "50%", "0", "100%", "2", wm ); 151 | button_set_name( "+", data->button_inc, wm ); 152 | button_set_handler( &button_inc_handler, data, data->button_inc, wm ); 153 | data->button_ins = create_window( "ins", 0, 1, win->x_size>>1, 2, wm->colors[9], 1, evt->event_win, &button_handler, wm ); 154 | set_window_string_controls( data->button_ins, "0", "0", "50%", "2", wm ); 155 | button_set_name( "INS", data->button_ins, wm ); 156 | button_set_handler( &button_ins_handler, data, data->button_ins, wm ); 157 | data->button_del = create_window( "bdel", 0, 3, win->x_size>>1, 2, wm->colors[9], 1, evt->event_win, &button_handler, wm ); 158 | set_window_string_controls( data->button_del, "0", "2", "50%", "4", wm ); 159 | button_set_name( "DEL", data->button_del, wm ); 160 | button_set_handler( &button_del_handler2, data, data->button_del, wm ); 161 | break; 162 | 163 | case EVT_BEFORECLOSE: 164 | if( win->data ) mem_free( win->data ); 165 | break; 166 | 167 | case EVT_SHOW: 168 | //Show window: 169 | win->visible = 1; //Make it visible 170 | send_event(evt->event_win, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm); //Send DRAW event to all childs 171 | break; 172 | 173 | case EVT_HIDE: 174 | win->visible = 0; 175 | break; 176 | 177 | case EVT_DRAW: 178 | //Draw window (if it's visible) 179 | if( win->visible ) 180 | { 181 | draw_window_touch_area( evt->event_win, wm ); 182 | draw_window_box( evt->event_win, wm ); //draw window box 183 | psypattern_draw_time( evt->event_win, wm ); //Draw time in this window 184 | } 185 | break; 186 | 187 | case EVT_REDRAW: 188 | //Redraw window (if it's visible) 189 | if( win->visible ) 190 | { 191 | draw_window_box( evt->event_win, wm ); //draw window box 192 | psypattern_draw_time( evt->event_win, wm ); //Draw time 193 | } 194 | break; 195 | } 196 | return 0; 197 | } 198 | -------------------------------------------------------------------------------- /MAKE/palmos/DebugMgr.h: -------------------------------------------------------------------------------- 1 | #ifndef __DEBUGMGR_H__ 2 | #define __DEBUGMGR_H__ 3 | 4 | // Include elementary types 5 | #include // Basic types 6 | #include // Trap Numbers. 7 | 8 | 9 | // 10 | // Constants and structures used in conjunction with DbgControl 11 | // 12 | #define dbgCtlNotHandled false // debug control operation was not handled 13 | #define dbgCtlHandled true // debug control operation was handled 14 | 15 | #define dbgCtlAllHandlersID 0 // indiacates that the operation is to be handled 16 | // by all handlers 17 | 18 | #define dbgCtlHandlerNameLen 31 // maximum handler name length, not including null 19 | #define dbgCtlHandlerVerLen 15 // maximum handler version string length, not including null 20 | 21 | #define dbgCtlFirstCustomOp 0x8000 // log.handlers begin numbering their op[erations] 22 | // with this number; the system reserves all operation 23 | // number values below this one 24 | // Typed of the DbgControl function 25 | typedef Boolean DbgControlFuncType(UInt32 handlerID, UInt16 op, void *paramP, UInt32 *dwParamP); 26 | 27 | typedef struct DbgCtlHandlerInfoType { 28 | DbgControlFuncType* handlerFuncP; // pointer to handler's DbgControl function 29 | UInt32 version; // numeric version number (hander-defined) 30 | Boolean enabled; // true if handler is enabled; false if not 31 | Char name[dbgCtlHandlerNameLen+1]; // null-terminated handler name 32 | Char ver[dbgCtlHandlerVerLen+1]; // null-terminated handler version string 33 | UInt8 reserved1; 34 | UInt32 dwReserved; // RESERVED -- CALLER MUST INITIALIZE TO ZERO! 35 | } DbgCtlHandlerInfoType; 36 | 37 | typedef void DbgCtlEnumCallbackFunc(void *callbackDataP, UInt32 handlerID, DbgControlFuncType* handlerFuncP); 38 | 39 | typedef struct DbgCtlEnumInfoType { 40 | DbgCtlEnumCallbackFunc* enumFuncP; 41 | void * callbackDataP; 42 | } DbgCtlEnumInfoType; 43 | 44 | // System-defined debug control operations 45 | enum { 46 | 47 | dbgCtlOpEnumHandlers = 1, // handlerID = dbgCtlAllHandlersID (applies to all handlers) 48 | // paramP = pointer to DbgCtlEnumInfoType 49 | // returns dbgCtlHandled if handled 50 | 51 | dbgCtlOpGetHandlerInfo, // handlerID = desired handler creator 52 | // paramP = pointer to DbgCtlHandlerInfoType 53 | // returns dbgCtlHandled if handled 54 | 55 | dbgCtlOpEnableHandler, // handlerID = desired handler creator or dbgCtlAllHandlersID 56 | // returns dbgCtlHandled if handled 57 | 58 | dbgCtlOpDisableHandler, // handlerID = desired handler creator or dbgCtlAllHandlersID 59 | // returns dbgCtlHandled if handled 60 | 61 | dbgCtlOpGetEnabledStatus, // handlerID = desired handler creator 62 | // dwParamP = pointer to UInt32 type variable to be filled in with 63 | // enabled status: non-zero = enabled, zero = disabled 64 | // returns dbgCtlHandled if handled 65 | 66 | dbgCtlOpGetVersion, // handlerID = desired handler creator 67 | // dwParamP = pointer to UInt32 type variable to be filled in with 68 | // handler-specific version number 69 | // returns dbgCtlHandled if handled 70 | 71 | 72 | dbgCtlOpLAST 73 | }; 74 | 75 | 76 | #ifdef __GNUC__ 77 | #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) 78 | #define _DEBUGGER_TRAP /*nop:(*/ 79 | #else 80 | #define _DEBUGGER_TRAP 81 | #endif 82 | #elif defined (__MWERKS__) /* The equivalent in CodeWarrior syntax */ 83 | #define _DEBUGGER_TRAP = 0x4E40 + 8 84 | #endif 85 | 86 | 87 | /************************************************************ 88 | * Prototypes 89 | *************************************************************/ 90 | #ifdef __cplusplus 91 | extern "C" { 92 | #endif 93 | 94 | Int32 DbgInit(MemPtr spaceP, MemPtr dispatchTableP[], Boolean openComm); 95 | 96 | void DbgSrcBreak(void) 97 | #if USE_TRAPS 98 | /* Use a trap instruction unless we're a simulator or we've explicitly 99 | set USE_TRAPS to 0. */ 100 | _DEBUGGER_TRAP 101 | #endif 102 | ; 103 | 104 | void DbgSrcMessage(const Char *debugStr) 105 | SYS_TRAP(sysTrapDbgSrcMessage); 106 | 107 | 108 | // Debug control function for implementing debug tracing, etc. via log.handlers. 109 | // The default implementation does nothing, leaving the real work up to "log.handlers". 110 | // Debug handlers will be implemented as system extensions. As they are loaded, extensions 111 | // will override this function call (DbgControl) and chain to those handlers loaded before 112 | // them. When a debug control call is made by the client, a handler id of the handler that 113 | // implements the functionality will be passed in as the first parameter. The handler id is 114 | // the unique creator id of the handler. When a handler is called, it will first examine 115 | // the handler ID -- if it matches its own, the handler will execute the command and return; 116 | // if the handler id does not match, the handler must pass the call down the chain and return 117 | // the value from that call. The operation to be performed is indicated by the parameter "op". 118 | // op is specific to each handler this means that the same op values may be used by different 119 | // handlers, since handler id's are unique. op values defined by handlers must begin at 120 | // dbgCtlFirstCustomOp. Handler ID of dbgCtlAllHandlersID applies to all handlers. When the 121 | // handler id of zero is passed, each handler is responsible for executing the requested action 122 | // and passing the call down the chain. The last two parameters are defined by each handler 123 | // for its own operations. 124 | //typedef Boolean DbgControlFuncType(UInt32 handlerID, UInt16 op, void *paramP, UInt32 *dwParamP); 125 | extern DbgControlFuncType DbgControl 126 | SYS_TRAP(sysTrapDbgControl); 127 | 128 | void DbgBreak(void) 129 | #if EMULATION_LEVEL == EMULATION_NONE 130 | /* Use a trap instruction unless we're a simulator (i.e., even if we've 131 | explicitly set USE_TRAPS to 0). In particular the SmallROM compiles 132 | with USE_TRAPS set to 0 and needs the DbgBreak to resolve as a trap 133 | instruction. */ 134 | _DEBUGGER_TRAP 135 | #endif 136 | ; 137 | 138 | void DbgMessage(const Char *aStr) 139 | SYS_TRAP(sysTrapDbgMessage); 140 | 141 | Char * DbgGetMessage(UInt8 *bufferP, Int32 timeout) 142 | SYS_TRAP(sysTrapDbgGetMessage); 143 | 144 | Err DbgCommSettings(UInt32 *baudP, UInt32 *flagsP) 145 | SYS_TRAP(sysTrapDbgCommSettings); 146 | 147 | #ifdef __cplusplus 148 | } 149 | #endif 150 | 151 | 152 | /************************************************************ 153 | * Assembly Function Prototypes 154 | *************************************************************/ 155 | 156 | // This is an optimization for assembly code on the device. 157 | #if EMULATION_LEVEL == EMULATION_NONE 158 | #define _DbgBreak \ 159 | DC.W m68kTrapInstr+sysDbgTrapNum //lint !e773 160 | #endif 161 | 162 | 163 | #endif // __DEBUGMGR_H__ 164 | -------------------------------------------------------------------------------- /wm/wm_palmos.h: -------------------------------------------------------------------------------- 1 | /* 2 | wm_palmos.h - platform-dependent module : PalmOS 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #pragma once 9 | 10 | #include 11 | #include 12 | #include "palm_functions.h" 13 | 14 | //################################# 15 | //## DEVICE DEPENDENT FUNCTIONS: ## 16 | //################################# 17 | 18 | void wait( void ) 19 | { 20 | int cur_ticks = time_ticks(); 21 | int counter = 0; 22 | while( time_ticks() < cur_ticks + ( time_ticks_per_second() / 2 ) ) 23 | { 24 | device_event_handler( 0 ); 25 | counter++; 26 | if( ( counter & 0xFFFF ) == 0 ) slog( "MAIN: waiting...\n" ); 27 | } 28 | } 29 | 30 | FormPtr gpForm; 31 | int formIsOpen = 0; 32 | int formResized = 0; 33 | 34 | void MainFormResize( FormPtr frmP ) 35 | { 36 | RectangleType dispBounds, bounds; 37 | 38 | // Get/Set the window bounds 39 | WinGetBounds( WinGetDisplayWindow(), &dispBounds ); 40 | WinSetWindowBounds( FrmGetWindowHandle(frmP), &dispBounds ); 41 | } 42 | 43 | Boolean FormHandler( EventPtr event ) 44 | { 45 | RectangleType bounds; 46 | UInt32 pinMgrVersion; 47 | Err err; 48 | Boolean handled = false; 49 | 50 | return handled; 51 | } 52 | 53 | Boolean ApplicationHandleEvent( EventPtr event ) 54 | { 55 | FormPtr frm; 56 | UInt16 formId; 57 | Boolean handled = false; 58 | FormPtr pForm; 59 | 60 | switch( BSwap16(event->eType) ) 61 | { 62 | case frmLoadEvent: 63 | unsigned short *ptr = (unsigned short*)event; 64 | pForm = FrmInitForm( BSwap16(ptr[4]) );//BSwap16(event->data.frmLoad.formID) ); 65 | 66 | FrmSetActiveForm( pForm ); 67 | 68 | FrmSetEventHandler( pForm, (Boolean (*)(EventType*))g_form_handler ); 69 | 70 | handled = true; 71 | break; 72 | } 73 | return handled; 74 | } 75 | 76 | void device_start( window_manager *wm ) 77 | { 78 | //Open window: 79 | #ifndef PALMOS_COMP_MODE 80 | slog( "MAIN: open form\n" ); 81 | FrmGotoForm( 8888 ); 82 | wait(); 83 | /* 84 | UInt32 pinMgrVersion; 85 | slog( "MAIN: FtrGet\n" ); 86 | Err err = FtrGet( pinCreator, pinFtrAPIVersion, &pinMgrVersion ); 87 | slog( "MAIN: waiting for form open/resize\n" ); 88 | if ( !err && pinMgrVersion != pinAPIVersion1_0 ) 89 | { //Palm with large screen: 90 | while( !formResized ) device_event_handler( 0 ); 91 | } 92 | else 93 | { //Palm like TungstenT (320x320 or 160x160): 94 | while( !formIsOpen ) device_event_handler( 0 ); 95 | } 96 | RectangleType bounds; 97 | //slog( "MAIN: get form ptr\n" ); 98 | FormType *fp;// = FrmGetFormPtr( 8888 ); 99 | for(;;) 100 | { 101 | device_event_handler( 0 ); fp = FrmGetFormPtr( 8888 ); 102 | if( fp ) 103 | { 104 | FrmGetFormBounds( fp, &bounds ); 105 | if( bounds.extent.x != 32 || bounds.extent.y != 32 ) break; 106 | } 107 | } 108 | slog( "MAIN: fp = %d\n", (int)fp ); 109 | slog( "MAIN: get form bounds\n" ); 110 | FrmGetFormBounds( fp, &bounds ); 111 | */ 112 | 113 | slog( "MAIN: get form size\n" ); 114 | #ifdef PALMLOWRES 115 | pscreen_x_size = 160;//bounds.extent.x; 116 | pscreen_y_size = 160;//bounds.extent.y; 117 | #else 118 | pscreen_x_size = 320;//bounds.extent.x << 1; 119 | pscreen_y_size = 320;//bounds.extent.y << 1; 120 | #endif 121 | 122 | #else //PALMOS_COMP_MODE (No forms): 123 | 124 | #ifdef PALMLOWRES 125 | pscreen_x_size = 160; 126 | pscreen_y_size = 160; 127 | #else 128 | pscreen_x_size = 320; 129 | pscreen_y_size = 320; 130 | #endif 131 | 132 | #endif 133 | slog( "MAIN: device start finished\n" ); 134 | } 135 | 136 | void device_end( window_manager *wm ) 137 | { 138 | //Close window: 139 | #ifndef PALMOS_COMP_MODE 140 | slog( "MAIN: close all forms\n" ); 141 | FrmCloseAllForms(); 142 | wait(); 143 | #else 144 | slog( "MAIN: device end\n" ); 145 | #endif 146 | } 147 | 148 | int old_chrr; 149 | 150 | int device_event_handler( window_manager *wm ) 151 | { 152 | EventType event; 153 | UInt16 error; 154 | int chrr,x,y; 155 | char keydown = 0; 156 | 157 | EvtGetEvent( &event, 0 ); 158 | 159 | if( wm ) 160 | { 161 | UInt16 *ptr = (UInt16*)&event; 162 | chrr = BSwap16( ptr[4] ); 163 | x = BSwap16( ptr[2] ); 164 | y = BSwap16( ptr[3] ); 165 | switch( BSwap16(event.eType) ) 166 | { 167 | #ifdef PALMLOWRES 168 | case penDownEvent: push_button( x, y, 1, 1023, 0, wm ); break; 169 | case penMoveEvent: push_button( x, y, 1, 1023, 2, wm ); break; 170 | case penUpEvent: push_button( x, y, 1, 1023, 1, wm ); break; 171 | #else 172 | case penDownEvent: push_button( x<<1, y<<1, 1, 1023, 0, wm ); break; 173 | case penMoveEvent: push_button( x<<1, y<<1, 1, 1023, 2, wm ); break; 174 | case penUpEvent: push_button( x<<1, y<<1, 1, 1023, 1, wm ); break; 175 | #endif 176 | case keyDownEvent: 177 | if( chrr >= 11 && chrr <= 12 ) keydown = 1; 178 | if( chrr >= 516 && chrr <= 519 ) keydown = 1; 179 | uint resulted_key; 180 | switch( chrr ) 181 | { 182 | case 0x1E: resulted_key = KEY_UP; break; 183 | case 0x1F: resulted_key = KEY_DOWN; break; 184 | case 0x1C: resulted_key = KEY_LEFT; break; 185 | case 0x1D: resulted_key = KEY_RIGHT; break; 186 | case 0x08: resulted_key = KEY_BACKSPACE; break; 187 | case 0x0A: resulted_key = KEY_ENTER; break; 188 | case 0x0B: resulted_key = KEY_UP; break; 189 | case 0x0C: resulted_key = KEY_DOWN; break; 190 | default: resulted_key = chrr; if( resulted_key > 255 ) resulted_key = 0; break; 191 | } 192 | push_button( 0, 0, resulted_key << 3, 1023, 0, wm ); 193 | break; 194 | /*case keyUpEvent: 195 | chrr = event.data.keyDown.chr; 196 | push_button( 0, 0, wm->buttons_table[ chrr ] << 3, 1023, 1, wm ); 197 | break;*/ 198 | } 199 | 200 | chrr = KeyCurrentState(); 201 | if( !keydown ) 202 | { 203 | if( chrr & 0x1000000 && !( old_chrr & 0x1000000 ) ) { push_button( 0, 0, KEY_LEFT << 3, 1023, 0, wm ); keydown = 1; } 204 | if( !( chrr & 0x1000000 ) && old_chrr & 0x1000000 ) { push_button( 0, 0, KEY_LEFT << 3, 1023, 1, wm ); } 205 | if( chrr & 0x2000000 && !( old_chrr & 0x2000000 ) ) { push_button( 0, 0, KEY_RIGHT << 3, 1023, 0, wm ); keydown = 1; } 206 | if( !( chrr & 0x2000000 ) && old_chrr & 0x2000000 ) { push_button( 0, 0, KEY_RIGHT << 3, 1023, 1, wm ); } 207 | if( chrr & 0x4000000 && !( old_chrr & 0x4000000 ) ) { push_button( 0, 0, KEY_SPACE << 3, 1023, 0, wm ); keydown = 1; } 208 | if( !( chrr & 0x4000000 ) && old_chrr & 0x4000000 ) { push_button( 0, 0, KEY_SPACE << 3, 1023, 1, wm ); } 209 | } 210 | old_chrr = chrr; 211 | 212 | } //if( wm ) 213 | 214 | if( !keydown ) 215 | { 216 | #ifndef PALMOS_COMP_MODE 217 | if( !SysHandleEvent(&event) && !MenuHandleEvent(0,&event,&error) && !ApplicationHandleEvent(&event) ) 218 | FrmDispatchEvent(&event); 219 | #else 220 | if( !SysHandleEvent( &event ) ) MenuHandleEvent( 0, &event,&error ); 221 | #endif 222 | } 223 | 224 | #ifndef PALMOS_COMP_MODE 225 | if( BSwap16( event.eType ) == winDisplayChangedEvent ) formResized = 1; 226 | if( BSwap16( event.eType ) == frmOpenEvent ) formIsOpen = 1; 227 | if( BSwap16( event.eType ) == frmCloseEvent ) formIsOpen = 0; 228 | if( BSwap16( event.eType ) == winExitEvent ) formIsOpen = 0; 229 | #endif 230 | if( BSwap16( event.eType ) == appStopEvent ) 231 | { 232 | if( wm ) push_button( pscreen_x_size / 2, pscreen_y_size - 40, KEY_ESCAPE<<3, 1023, 0, wm ); 233 | } 234 | 235 | if( wm ) if( wm->exit_flag ) return 1; 236 | 237 | return 0; 238 | } 239 | 240 | //################################# 241 | //################################# 242 | //################################# 243 | -------------------------------------------------------------------------------- /MAKE/palmos/PalmTypes.h: -------------------------------------------------------------------------------- 1 | #ifndef __PALMTYPES_H__ 2 | #define __PALMTYPES_H__ 3 | 4 | 5 | /************************************************************ 6 | * Environment configuration 7 | *************************************************************/ 8 | // must be included here, rather than in 9 | // because they must be included for ALL builds. 10 | // Not every build includes . 11 | 12 | // To override build options in a local component, include 13 | // first, then define switches as need, and THEN include . 14 | // This new mechanism supercedes the old "AppBuildRules.h" approach. 15 | // More details available in . 16 | #include 17 | 18 | 19 | /************************************************************ 20 | * Useful Macros 21 | *************************************************************/ 22 | #if defined(__GNUC__) && defined(__UNIX__) // used to be in 23 | // Ensure that structure elements are 16-bit aligned 24 | // Other [host] development platforms may need this as well... 25 | #pragma pack(2) 26 | #endif 27 | 28 | 29 | /******************************************************************** 30 | * Elementary data types 31 | ********************************************************************/ 32 | // Determine if we need to define our basic types or not 33 | #ifndef __TYPES__ // (Already defined in CW11) 34 | #ifndef __MACTYPES__ // (Already defined in CWPro3) 35 | #define __DEFINE_TYPES_ 1 36 | #endif 37 | #endif 38 | 39 | 40 | // Fixed size data types 41 | typedef signed char Int8; 42 | typedef signed short Int16; 43 | typedef signed long Int32; 44 | 45 | #if __DEFINE_TYPES_ 46 | typedef unsigned char UInt8; 47 | typedef unsigned short UInt16; 48 | typedef unsigned long UInt32; 49 | #endif 50 | 51 | 52 | // Logical data types 53 | #if __DEFINE_TYPES_ 54 | typedef unsigned char Boolean; 55 | #endif 56 | 57 | typedef char Char; 58 | typedef UInt16 WChar; // 'wide' int'l character type. 59 | 60 | typedef UInt16 Err; 61 | 62 | typedef UInt32 LocalID; // local (card relative) chunk ID 63 | 64 | typedef Int16 Coord; // screen/window coordinate 65 | 66 | 67 | typedef void * MemPtr; // global pointer 68 | typedef struct _opaque *MemHandle; // global handle 69 | 70 | 71 | #if __DEFINE_TYPES_ 72 | typedef Int32 (*ProcPtr)(); 73 | #endif 74 | 75 | 76 | /************************************************************ 77 | * Useful Macros 78 | *************************************************************/ 79 | 80 | // The min() and max() macros which used to be defined here have been removed 81 | // because they conflicted with facilities in C++. If you need them, you 82 | // should define them yourself, or see PalmUtils.h -- but please read the 83 | // comments in that file before using it in your own projects. 84 | 85 | 86 | #define OffsetOf(type, member) ((UInt32) &(((type *) 0)->member)) 87 | 88 | 89 | 90 | 91 | /************************************************************ 92 | * Common constants 93 | *************************************************************/ 94 | #ifndef NULL 95 | #define NULL 0 96 | #endif // NULL 97 | 98 | #ifndef bitsInByte 99 | #define bitsInByte 8 100 | #endif // bitsInByte 101 | 102 | 103 | // Include the following typedefs if types.h wasn't read. 104 | #if __DEFINE_TYPES_ 105 | #ifdef __MWERKS__ 106 | #if !__option(bool) 107 | #ifndef true 108 | #define true 1 109 | #endif 110 | #ifndef false 111 | #define false 0 112 | #endif 113 | #endif 114 | #else 115 | #ifndef __cplusplus 116 | #ifndef true 117 | enum {false, true}; 118 | #endif 119 | #endif 120 | #endif 121 | #endif /* __TYPES__ */ 122 | 123 | 124 | 125 | 126 | /************************************************************ 127 | * Misc 128 | *************************************************************/ 129 | 130 | // Standardized infinite loop notation 131 | // Use in place of while(1), while(true), while(!0), ... 132 | #define loop_forever for (;;) 133 | 134 | 135 | // Include M68KHwr.h: 136 | #if EMULATION_LEVEL == EMULATION_NONE 137 | #if CPU_TYPE == CPU_68K 138 | #include 139 | //#pragma warn_no_side_effect on 140 | #endif 141 | #endif 142 | 143 | /************************************************************ 144 | * Metrowerks will substitute strlen and strcpy with inline 145 | * 68K assembly code. Prevent this. 146 | *************************************************************/ 147 | 148 | #ifdef __MC68K__ 149 | #define _NO_FAST_STRING_INLINES_ 0 150 | #endif 151 | 152 | 153 | /************************************************************ 154 | * Define whether or not we are direct linking, or going through 155 | * traps. 156 | * 157 | * When eumulating we use directy linking. 158 | * When running under native mode, we use traps EXCEPT for the 159 | * modules that actually install the routines into the trap table. 160 | * These modules will set the DIRECT_LINK define to 1 161 | *************************************************************/ 162 | #ifndef EMULATION_LEVEL 163 | #error "This should not happen!" 164 | #endif 165 | 166 | #ifndef USE_TRAPS 167 | #if EMULATION_LEVEL == EMULATION_NONE 168 | #define USE_TRAPS 1 // use Pilot traps 169 | #else 170 | #define USE_TRAPS 0 // direct link (Simulator) 171 | #endif 172 | #endif 173 | 174 | 175 | /******************************************************************** 176 | * Palm OS System and Library trap macro definitions: 177 | ********************************************************************/ 178 | 179 | #define _DIRECT_CALL(table, vector) 180 | #define _DIRECT_CALL_WITH_SELECTOR(table, vector, selector) 181 | #define _DIRECT_CALL_WITH_16BIT_SELECTOR(table, vector, selector) 182 | 183 | #ifndef _STRUCTURE_PICTURES 184 | 185 | #define _SYSTEM_TABLE 15 186 | #define _HAL_TABLE 15 187 | 188 | #ifdef __GNUC__ 189 | 190 | #if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) 191 | 192 | #ifndef _Str 193 | #define _Str(X) #X 194 | #endif 195 | 196 | #define _OS_CALL(table, vector) /**/ 197 | #define _OS_CALL_WITH_SELECTOR(table, vector, selector) /**/ 198 | 199 | #define _OS_CALL_WITH_16BIT_SELECTOR(table, vector, selector) /**/ 200 | 201 | #else 202 | 203 | #define _OS_CALL(table, vector) /**/ 204 | #define _OS_CALL_WITH_SELECTOR(table, vector, selector) 205 | #define _OS_CALL_WITH_16BIT_SELECTOR(table, vector, selector) 206 | 207 | #endif 208 | 209 | #elif defined (__MWERKS__) /* The equivalent in CodeWarrior syntax */ 210 | 211 | #define _OS_CALL(table, vector) \ 212 | = { 0x4E40 + table, vector } 213 | 214 | #define _OS_CALL_WITH_SELECTOR(table, vector, selector) \ 215 | = { 0x7400 + selector, 0x4E40 + table, vector } 216 | 217 | #define _OS_CALL_WITH_16BIT_SELECTOR(table, vector, selector) \ 218 | = { 0x3F3C, selector, 0x4E40 + table, vector, 0x544F } 219 | 220 | #endif 221 | 222 | #else 223 | 224 | #define _SYSTEM_TABLE "systrap" 225 | #define _HAL_TABLE "hal" 226 | 227 | #define _OS_CALL(table, vector) /**/ 228 | 229 | #define _OS_CALL_WITH_SELECTOR(table, vector, selector) /**/ 230 | 231 | #define _OS_CALL_WITH_16BIT_SELECTOR(table, vector, selector) /**/ 232 | 233 | #endif 234 | 235 | 236 | #if EMULATION_LEVEL != EMULATION_NONE 237 | 238 | #define _HAL_API(kind) _DIRECT##kind 239 | #define _SYSTEM_API(kind) _DIRECT##kind 240 | 241 | #elif USE_TRAPS == 0 242 | 243 | #define _HAL_API(kind) _OS##kind 244 | #define _SYSTEM_API(kind) _DIRECT##kind 245 | 246 | #else 247 | 248 | #define _HAL_API(kind) _OS##kind 249 | #define _SYSTEM_API(kind) _OS##kind 250 | 251 | #endif 252 | 253 | 254 | /************************************************************ 255 | * Palm specific TRAP instruction numbers 256 | *************************************************************/ 257 | #define sysDbgBreakpointTrapNum 0 // For soft breakpoints 258 | #define sysDbgTrapNum 8 // For compiled breakpoints 259 | #define sysDispatchTrapNum 15 // Trap dispatcher 260 | 261 | 262 | #define SYS_TRAP(trapNum) /**/ 263 | 264 | #define ASM_SYS_TRAP(trapNum) /**/ 265 | 266 | 267 | #endif //__PALMTYPES_H__ 268 | -------------------------------------------------------------------------------- /xm/xm_tables.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | xm_tables.cpp - special tables 3 | This file is public domain 4 | */ 5 | 6 | #include "../core/core.h" 7 | 8 | //linear_tab[ i ] = pow( 2.0, 1.0 - i / 768.0 ) * 267616.0 9 | uint linear_tab[768] = 10 | { 11 | 535232, 534749, 534266, 533784, 533303, 532822, 532341, 531861, 12 | 531381, 530902, 530423, 529944, 529466, 528988, 528511, 528034, 13 | 527558, 527082, 526607, 526131, 525657, 525183, 524709, 524236, 14 | 523763, 523290, 522818, 522346, 521875, 521404, 520934, 520464, 15 | 519994, 519525, 519057, 518588, 518121, 517653, 517186, 516720, 16 | 516253, 515788, 515322, 514858, 514393, 513929, 513465, 513002, 17 | 512539, 512077, 511615, 511154, 510692, 510232, 509771, 509312, 18 | 508852, 508393, 507934, 507476, 507018, 506561, 506104, 505647, 19 | 505191, 504735, 504280, 503825, 503371, 502917, 502463, 502010, 20 | 501557, 501104, 500652, 500201, 499749, 499298, 498848, 498398, 21 | 497948, 497499, 497050, 496602, 496154, 495706, 495259, 494812, 22 | 494366, 493920, 493474, 493029, 492585, 492140, 491696, 491253, 23 | 490809, 490367, 489924, 489482, 489041, 488600, 488159, 487718, 24 | 487278, 486839, 486400, 485961, 485522, 485084, 484647, 484210, 25 | 483773, 483336, 482900, 482465, 482029, 481595, 481160, 480726, 26 | 480292, 479859, 479426, 478994, 478562, 478130, 477699, 477268, 27 | 476837, 476407, 475977, 475548, 475119, 474690, 474262, 473834, 28 | 473407, 472979, 472553, 472126, 471701, 471275, 470850, 470425, 29 | 470001, 469577, 469153, 468730, 468307, 467884, 467462, 467041, 30 | 466619, 466198, 465778, 465358, 464938, 464518, 464099, 463681, 31 | 463262, 462844, 462427, 462010, 461593, 461177, 460760, 460345, 32 | 459930, 459515, 459100, 458686, 458272, 457859, 457446, 457033, 33 | 456621, 456209, 455797, 455386, 454975, 454565, 454155, 453745, 34 | 453336, 452927, 452518, 452110, 451702, 451294, 450887, 450481, 35 | 450074, 449668, 449262, 448857, 448452, 448048, 447644, 447240, 36 | 446836, 446433, 446030, 445628, 445226, 444824, 444423, 444022, 37 | 443622, 443221, 442821, 442422, 442023, 441624, 441226, 440828, 38 | 440430, 440033, 439636, 439239, 438843, 438447, 438051, 437656, 39 | 437261, 436867, 436473, 436079, 435686, 435293, 434900, 434508, 40 | 434116, 433724, 433333, 432942, 432551, 432161, 431771, 431382, 41 | 430992, 430604, 430215, 429827, 429439, 429052, 428665, 428278, 42 | 427892, 427506, 427120, 426735, 426350, 425965, 425581, 425197, 43 | 424813, 424430, 424047, 423665, 423283, 422901, 422519, 422138, 44 | 421757, 421377, 420997, 420617, 420237, 419858, 419479, 419101, 45 | 418723, 418345, 417968, 417591, 417214, 416838, 416462, 416086, 46 | 415711, 415336, 414961, 414586, 414212, 413839, 413465, 413092, 47 | 412720, 412347, 411975, 411604, 411232, 410862, 410491, 410121, 48 | 409751, 409381, 409012, 408643, 408274, 407906, 407538, 407170, 49 | 406803, 406436, 406069, 405703, 405337, 404971, 404606, 404241, 50 | 403876, 403512, 403148, 402784, 402421, 402058, 401695, 401333, 51 | 400970, 400609, 400247, 399886, 399525, 399165, 398805, 398445, 52 | 398086, 397727, 397368, 397009, 396651, 396293, 395936, 395579, 53 | 395222, 394865, 394509, 394153, 393798, 393442, 393087, 392733, 54 | 392378, 392024, 391671, 391317, 390964, 390612, 390259, 389907, 55 | 389556, 389204, 388853, 388502, 388152, 387802, 387452, 387102, 56 | 386753, 386404, 386056, 385707, 385359, 385012, 384664, 384317, 57 | 383971, 383624, 383278, 382932, 382587, 382242, 381897, 381552, 58 | 381208, 380864, 380521, 380177, 379834, 379492, 379149, 378807, 59 | 378466, 378124, 377783, 377442, 377102, 376762, 376422, 376082, 60 | 375743, 375404, 375065, 374727, 374389, 374051, 373714, 373377, 61 | 373040, 372703, 372367, 372031, 371695, 371360, 371025, 370690, 62 | 370356, 370022, 369688, 369355, 369021, 368688, 368356, 368023, 63 | 367691, 367360, 367028, 366697, 366366, 366036, 365706, 365376, 64 | 365046, 364717, 364388, 364059, 363731, 363403, 363075, 362747, 65 | 362420, 362093, 361766, 361440, 361114, 360788, 360463, 360137, 66 | 359813, 359488, 359164, 358840, 358516, 358193, 357869, 357547, 67 | 357224, 356902, 356580, 356258, 355937, 355616, 355295, 354974, 68 | 354654, 354334, 354014, 353695, 353376, 353057, 352739, 352420, 69 | 352103, 351785, 351468, 351150, 350834, 350517, 350201, 349885, 70 | 349569, 349254, 348939, 348624, 348310, 347995, 347682, 347368, 71 | 347055, 346741, 346429, 346116, 345804, 345492, 345180, 344869, 72 | 344558, 344247, 343936, 343626, 343316, 343006, 342697, 342388, 73 | 342079, 341770, 341462, 341154, 340846, 340539, 340231, 339924, 74 | 339618, 339311, 339005, 338700, 338394, 338089, 337784, 337479, 75 | 337175, 336870, 336566, 336263, 335959, 335656, 335354, 335051, 76 | 334749, 334447, 334145, 333844, 333542, 333242, 332941, 332641, 77 | 332341, 332041, 331741, 331442, 331143, 330844, 330546, 330247, 78 | 329950, 329652, 329355, 329057, 328761, 328464, 328168, 327872, 79 | 327576, 327280, 326985, 326690, 326395, 326101, 325807, 325513, 80 | 325219, 324926, 324633, 324340, 324047, 323755, 323463, 323171, 81 | 322879, 322588, 322297, 322006, 321716, 321426, 321136, 320846, 82 | 320557, 320267, 319978, 319690, 319401, 319113, 318825, 318538, 83 | 318250, 317963, 317676, 317390, 317103, 316817, 316532, 316246, 84 | 315961, 315676, 315391, 315106, 314822, 314538, 314254, 313971, 85 | 313688, 313405, 313122, 312839, 312557, 312275, 311994, 311712, 86 | 311431, 311150, 310869, 310589, 310309, 310029, 309749, 309470, 87 | 309190, 308911, 308633, 308354, 308076, 307798, 307521, 307243, 88 | 306966, 306689, 306412, 306136, 305860, 305584, 305308, 305033, 89 | 304758, 304483, 304208, 303934, 303659, 303385, 303112, 302838, 90 | 302565, 302292, 302019, 301747, 301475, 301203, 300931, 300660, 91 | 300388, 300117, 299847, 299576, 299306, 299036, 298766, 298497, 92 | 298227, 297958, 297689, 297421, 297153, 296884, 296617, 296349, 93 | 296082, 295815, 295548, 295281, 295015, 294749, 294483, 294217, 94 | 293952, 293686, 293421, 293157, 292892, 292628, 292364, 292100, 95 | 291837, 291574, 291311, 291048, 290785, 290523, 290261, 289999, 96 | 289737, 289476, 289215, 288954, 288693, 288433, 288173, 287913, 97 | 287653, 287393, 287134, 286875, 286616, 286358, 286099, 285841, 98 | 285583, 285326, 285068, 284811, 284554, 284298, 284041, 283785, 99 | 283529, 283273, 283017, 282762, 282507, 282252, 281998, 281743, 100 | 281489, 281235, 280981, 280728, 280475, 280222, 279969, 279716, 101 | 279464, 279212, 278960, 278708, 278457, 278206, 277955, 277704, 102 | 277453, 277203, 276953, 276703, 276453, 276204, 275955, 275706, 103 | 275457, 275209, 274960, 274712, 274465, 274217, 273970, 273722, 104 | 273476, 273229, 272982, 272736, 272490, 272244, 271999, 271753, 105 | 271508, 271263, 271018, 270774, 270530, 270286, 270042, 269798, 106 | 269555, 269312, 269069, 268826, 268583, 268341, 268099, 267857 107 | }; 108 | 109 | //Half-sine: 110 | uint8_t vibrato_tab[256] = 111 | { 112 | 0, 3, 6, 9, 12, 15, 18, 21, 25, 28, 31, 34, 37, 40, 43, 46, 113 | 49, 52, 56, 59, 62, 65, 68, 71, 74, 77, 80, 83, 86, 89, 92, 95, 114 | 97, 100, 103, 106, 109, 112, 115, 117, 120, 123, 126, 128, 131, 134, 136, 139, 115 | 142, 144, 147, 149, 152, 154, 157, 159, 162, 164, 167, 169, 171, 174, 176, 178, 116 | 180, 183, 185, 187, 189, 191, 193, 195, 197, 199, 201, 203, 205, 207, 209, 211, 117 | 212, 214, 216, 217, 219, 221, 222, 224, 225, 227, 228, 229, 231, 232, 233, 235, 118 | 236, 237, 238, 239, 240, 242, 243, 243, 244, 245, 246, 247, 248, 249, 249, 250, 119 | 251, 251, 252, 252, 253, 253, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 120 | 255, 255, 255, 255, 255, 255, 255, 255, 254, 254, 254, 253, 253, 252, 252, 251, 121 | 251, 250, 249, 249, 248, 247, 246, 245, 245, 244, 243, 242, 241, 240, 238, 237, 122 | 236, 235, 234, 232, 231, 230, 228, 227, 225, 224, 222, 221, 219, 218, 216, 214, 123 | 213, 211, 209, 207, 205, 203, 201, 200, 198, 196, 194, 191, 189, 187, 185, 183, 124 | 181, 179, 176, 174, 172, 169, 167, 165, 162, 160, 157, 155, 152, 150, 147, 145, 125 | 142, 139, 137, 134, 131, 129, 126, 123, 120, 118, 115, 112, 109, 106, 104, 101, 126 | 98, 95, 92, 89, 86, 83, 80, 77, 74, 71, 68, 65, 62, 59, 56, 53, 127 | 50, 47, 44, 41, 37, 34, 31, 28, 25, 22, 19, 16, 12, 9, 6, 3 128 | }; 129 | 130 | uint16_t stereo_tab[ 256 * 2 ]; //l,r, l,r, l,r, ... min/max: 0/1024 131 | 132 | void tables_init() 133 | { 134 | uint16_t a; 135 | for( a = 0; a < 256; a++ ) 136 | { 137 | stereo_tab[ ( a << 1 ) ] = ( 255 - a ) << 2; 138 | stereo_tab[ ( a << 1 ) + 1 ] = a << 2; 139 | } 140 | } 141 | -------------------------------------------------------------------------------- /wm/wm.h: -------------------------------------------------------------------------------- 1 | #pragma once 2 | 3 | //window size quantum = 1 text character (for example: 8x8); 4 | //you need to redraw all windows, if some window was moved or resized; 5 | //root window or dialog must use draw_window_touch_area() on DRAW event handling; 6 | //child windows (buttons, scrollbars etc) must use draw_touch_box() on DRAW event handling. 7 | 8 | #include "../core/core.h" 9 | #include "wm_struct.h" 10 | 11 | extern int pscreen_x_size; //Screen x-size (in pixels) 12 | extern int pscreen_y_size; //Screen y-size (is pixels) 13 | extern int char_x_size; //One char (symbol) x-size 14 | extern int char_y_size; //One char (symbol) y-size 15 | 16 | #ifdef OS_LINUX 17 | extern int mouse_auto_keyup; 18 | #endif 19 | 20 | extern unsigned char font[2048]; 21 | 22 | //################################ 23 | //## MAIN FUNCTIONS: ## 24 | //################################ 25 | 26 | void win_init( window_manager* ); //init window manager 27 | void win_close( window_manager* ); //close window manager 28 | void resize_all_windows( window_manager* ); //resize (using win string controls) all windows 29 | void resize_all( int, window_manager* ); //resize (reinit) all screens and windows 30 | 31 | //################################ 32 | //## EVENT FUNCTIONS: ## 33 | //################################ 34 | 35 | void event_loop(window_manager*, int loop); //main event loop 36 | void set_eventloop_handler( void (*)( window_manager* ), window_manager * ); //set user-defined eventloop handler 37 | int process_event(wm_event*,window_manager*); //process event 38 | void send_event(int,int,int x,int y,int button, int pressure, int mode, window_manager*); 39 | //send event to some window 40 | //################################ 41 | //## WIN HANDLERS: ## 42 | //################################ 43 | 44 | int null_handler(wm_event*,window_manager*); //SIMPLE WIN HANDLER: null window 45 | int child_handler(wm_event*,window_manager*); //SIMPLE WIN HANDLER: child window 46 | int desktop_handler(wm_event*,window_manager*); //SIMPLE WIN HANDLER: desktop window 47 | int create_scrollarea(int win_num,window_manager*); // 48 | int scrollarea_handler(wm_event*,window_manager*); //SIMPLE WIN HANDLER: small scroll buttons for an window 49 | int keyboard_handler(wm_event*,window_manager*); //SIMPLE WIN HANDLER: virtual keyboard 50 | void show_keyboard( int kbd_win, window_manager *wm, int show ); //show: -1 - switch; 0 - hide; 1 - show; 51 | 52 | //################################ 53 | //## TIME FUNCTIONS: ## 54 | //################################ 55 | 56 | void wm_timer_set( uint t, void (*)( void*, window_manager* ), void *data, window_manager *wm ); //Set timer. 1024 = one second 57 | void wm_timer_close( window_manager *wm ); 58 | 59 | //################################ 60 | //## CONNECTION WITH THE OS: ## 61 | //################################ 62 | 63 | void push_button(int x,int y,int button,int pressure, //Send button press/move/unpress event to the window manager 64 | int type,window_manager *wm); //x/y: coordinates on the screen (in pixels) 65 | //button: 1 - left; 2 - middle; 4 - right; 8 - keyboard... 66 | //pressure: button pressure (for MIDI or Digital Pen) 67 | //type: 0 - down; 1 - up; 2 - move 68 | //This function must be called by OS 69 | 70 | //################################ 71 | //## WINDOW FUNCTIONS: ## 72 | //################################ 73 | 74 | int create_window(const char *name, 75 | int x,int y,int x_size, int y_size, int color, int draw_box, 76 | int parent, 77 | int (*)(wm_event*,window_manager*), 78 | window_manager*); 79 | void close_window(int win_number, window_manager*); 80 | void create_child(int parent, int child_win, window_manager *wm); 81 | void move_window( int win_num, int x, int y, window_manager *wm ); 82 | void calculate_real_window_position( int win_num, window_manager *wm ); //Calculate real window values 83 | void calculate_real_window_position_with_childs( int win_num, window_manager *wm ); //Calculate real window values 84 | void set_window_string_controls( int win_num, const char *xs, const char *ys, const char *xs2, const char *ys2, window_manager *wm ); 85 | 86 | //################################ 87 | //## DRAWING FUNCTIONS: ## 88 | //################################ 89 | 90 | void int_to_string( int value, char *str ); //DEC 91 | void int_to_string_h( int value, char *str ); //HEX 92 | void ext_int_to_string( int value, char *str, int chars, window_manager* ); 93 | int get_color( uint8_t r, uint8_t g, uint8_t b ); //Get color value by RGB 94 | int red( COLOR c ); 95 | int green( COLOR c ); 96 | int blue( COLOR c ); 97 | COLOR blend( COLOR c1, COLOR c2, int value ); 98 | void load_font( window_manager* ); //Load user font (font.bmp) 99 | void load_background( window_manager* ); //Load user background (back.bmp) and init color gradient 100 | void draw_string(int,int,int,int,const char*,window_manager*); //draw text string (relative x/y in pixels) in some window 101 | void draw_pixel( int win_num, int x, int y, int color, window_manager *wm ); 102 | void draw_rectangle( int win_num, int x, int y, int x_size, int y_size, int color, window_manager *wm ); 103 | void draw_rectangle2( int win_num, int x, int y, int x_size, int y_size, int color, window_manager *wm ); 104 | void draw_line( int win_num, int x1, int y1, int x2, int y2, COLOR color, window_manager *wm ); 105 | void draw_vert_line( int win_num, int x, int y, int y_size, int color, int add, window_manager *wm ); 106 | void draw_horis_line( int win_num, int x, int y, int x_size, int color, int add, window_manager *wm ); 107 | void pdraw_box(int win_num, int x, int y, //Draw box (ralative x/y in pixels) in some window 108 | int x_size, int y_size, int color, 109 | window_manager*); 110 | void draw_box(int win_num, int x, int y, //Draw box (ralative x/y in symbols) in some window 111 | int x_size, int y_size, int color, 112 | int chr, window_manager*); 113 | //Draw touch box (for the new child-window) on exist window: 114 | void draw_touch_box( int back_win, int x, int y, int x_size, int y_size, 115 | int fore_win, window_manager *wm ); 116 | void matrix_draw_string(int,int,int,uint8_t,const char*,window_manager*); //draw text string in matrix 117 | //(relative x/y in symbols) 118 | void matrix_draw_box(int win_num, int x, int y, //Draw box in matrix 119 | int x_size, int y_size, int color, //(ralative x/y in symbols) 120 | window_manager*); 121 | void matrix_clear_box(int win_num, int x, int y, //Clear box in matrix 122 | int x_size, int y_size, //(ralative x/y in symbols) 123 | window_manager*); 124 | void matrix_draw( window_manager* ); 125 | void draw_window_box(int,window_manager*); //draw window box 126 | //Draw touch box (for the new parent window) over all windows: 127 | void draw_window_touch_area(int,window_manager*); //draw window touch area 128 | void redraw_screen(window_manager*); //redraw full screen 129 | 130 | //################################ 131 | //## DEVICE DEPENDENT: ## 132 | //################################ 133 | 134 | void create_active_screen_part(window_manager*); //DEVICE DEPENDENT: create active screen part 135 | void close_active_screen_part(window_manager*); //DEVICE DEPENDENT: close active screen part 136 | void fast_draw_char(int ptr,int,int,uint8_t,window_manager*);//DEVICE DEPENDENT: fast draw symbol 137 | void draw_char(int,int,int,int,window_manager*); //DEVICE DEPENDENT: draw one symbol (x/y in pixels) 138 | void draw_screen_part(int,window_manager*); //DEVICE DEPENDENT: draw active screen part 139 | void draw_screen(window_manager*); //DEVICE DEPENDENT: draw changed parts of the screen 140 | void set_palette(window_manager*); //DEVICE DEPENDENT: set RGB palette 141 | 142 | //################################ 143 | //## DECLARED IN EVENTLOOP.C: ## 144 | //################################ 145 | 146 | int device_event_handler(window_manager*); //DEVICE DEPENDENT: device event handler (return 1 for EXIT) 147 | void device_start(window_manager*); //DEVICE DEPENDENT: device start (before main loop) 148 | void device_end(window_manager*); //DEVICE DEPENDENT: device end (after main loop) 149 | -------------------------------------------------------------------------------- /wm/wm_font.h: -------------------------------------------------------------------------------- 1 | /* 2 | wm_font.h - binary font 8x8 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2007 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | unsigned char font[ 2048 ] = { 9 | 0, 0, 0, 0, 0, 0, 0, 0, 10 | 0, 0, 24, 36, 66, 255, 0, 0, 11 | 0, 0, 255, 66, 36, 24, 0, 0, 12 | 4, 12, 20, 36, 36, 20, 12, 4, 13 | 32, 48, 40, 36, 36, 40, 48, 32, 14 | 0, 0, 0, 0, 0, 0, 0, 0, 15 | 0, 0, 0, 0, 0, 0, 0, 0, 16 | 0, 0, 0, 0, 0, 0, 0, 0, 17 | 0, 0, 0, 0, 0, 0, 0, 0, 18 | 0, 0, 0, 0, 0, 0, 0, 0, 19 | 0, 0, 0, 0, 0, 0, 0, 0, 20 | 0, 0, 0, 0, 0, 0, 0, 0, 21 | 0, 0, 0, 0, 0, 0, 0, 0, 22 | 0, 0, 0, 0, 0, 0, 0, 0, 23 | 0, 0, 0, 0, 0, 0, 0, 0, 24 | 0, 0, 0, 0, 0, 0, 0, 0, 25 | 0, 0, 0, 0, 0, 0, 0, 0, 26 | 0, 0, 0, 0, 0, 0, 0, 0, 27 | 0, 0, 0, 0, 0, 0, 0, 0, 28 | 0, 0, 0, 0, 0, 0, 0, 0, 29 | 0, 0, 0, 0, 0, 0, 0, 0, 30 | 0, 0, 0, 0, 0, 0, 0, 0, 31 | 0, 0, 0, 0, 0, 0, 0, 0, 32 | 0, 0, 0, 0, 0, 0, 0, 0, 33 | 0, 0, 0, 0, 0, 0, 0, 0, 34 | 0, 0, 0, 0, 0, 0, 0, 0, 35 | 0, 0, 0, 0, 0, 0, 0, 0, 36 | 0, 0, 0, 0, 0, 0, 0, 0, 37 | 0, 0, 0, 0, 0, 0, 0, 0, 38 | 0, 0, 0, 0, 0, 0, 0, 0, 39 | 0, 0, 0, 0, 0, 0, 0, 0, 40 | 0, 0, 0, 0, 0, 0, 0, 0, 41 | 0, 0, 0, 0, 0, 0, 0, 0, 42 | 8, 8, 8, 8, 8, 0, 8, 0, 43 | 36, 36, 36, 0, 0, 0, 0, 0, 44 | 36, 36, 126, 36, 126, 36, 36, 0, 45 | 24, 126, 64, 126, 2, 126, 24, 0, 46 | 97, 98, 4, 8, 16, 35, 67, 0, 47 | 48, 72, 48, 74, 132, 76, 50, 0, 48 | 24, 8, 16, 0, 0, 0, 0, 0, 49 | 24, 32, 32, 32, 32, 32, 24, 0, 50 | 24, 4, 4, 4, 4, 4, 24, 0, 51 | 0, 36, 24, 126, 24, 36, 0, 0, 52 | 0, 8, 8, 62, 8, 8, 0, 0, 53 | 0, 0, 0, 0, 0, 24, 8, 16, 54 | 0, 0, 0, 126, 0, 0, 0, 0, 55 | 0, 0, 0, 0, 0, 24, 24, 0, 56 | 1, 2, 4, 8, 16, 32, 64, 0, 57 | 127, 65, 65, 73, 65, 65, 127, 0, 58 | 120, 8, 8, 8, 8, 8, 127, 0, 59 | 127, 1, 1, 127, 64, 64, 127, 0, 60 | 127, 1, 1, 31, 1, 1, 127, 0, 61 | 65, 65, 65, 127, 1, 1, 1, 0, 62 | 127, 64, 64, 127, 1, 1, 127, 0, 63 | 127, 64, 64, 127, 65, 65, 127, 0, 64 | 127, 1, 1, 1, 1, 1, 1, 0, 65 | 127, 65, 65, 127, 65, 65, 127, 0, 66 | 127, 65, 65, 127, 1, 1, 127, 0, 67 | 0, 24, 24, 0, 0, 24, 24, 0, 68 | 0, 24, 24, 0, 0, 24, 8, 16, 69 | 4, 8, 16, 32, 16, 8, 4, 0, 70 | 0, 126, 0, 0, 126, 0, 0, 0, 71 | 32, 16, 8, 4, 8, 16, 32, 0, 72 | 126, 2, 2, 30, 24, 0, 24, 0, 73 | 127, 64, 64, 95, 93, 65, 127, 0, 74 | 127, 65, 65, 127, 65, 65, 65, 0, 75 | 126, 66, 66, 127, 65, 65, 127, 0, 76 | 127, 64, 64, 64, 64, 64, 127, 0, 77 | 120, 68, 66, 65, 65, 65, 127, 0, 78 | 127, 64, 64, 124, 64, 64, 127, 0, 79 | 127, 64, 64, 124, 64, 64, 64, 0, 80 | 127, 64, 64, 64, 67, 65, 127, 0, 81 | 65, 65, 65, 127, 65, 65, 65, 0, 82 | 127, 8, 8, 8, 8, 8, 127, 0, 83 | 1, 1, 1, 65, 65, 65, 127, 0, 84 | 65, 66, 68, 120, 68, 66, 65, 0, 85 | 64, 64, 64, 64, 64, 64, 127, 0, 86 | 65, 99, 85, 73, 65, 65, 65, 0, 87 | 65, 97, 81, 73, 69, 67, 65, 0, 88 | 127, 65, 65, 65, 65, 65, 127, 0, 89 | 127, 65, 65, 127, 64, 64, 64, 0, 90 | 127, 65, 65, 65, 69, 67, 127, 0, 91 | 127, 65, 65, 127, 68, 66, 65, 0, 92 | 127, 64, 64, 127, 1, 1, 127, 0, 93 | 127, 8, 8, 8, 8, 8, 8, 0, 94 | 65, 65, 65, 65, 65, 65, 127, 0, 95 | 65, 65, 65, 65, 34, 20, 8, 0, 96 | 65, 65, 65, 73, 85, 99, 65, 0, 97 | 65, 34, 20, 8, 20, 34, 65, 0, 98 | 65, 34, 20, 8, 8, 8, 8, 0, 99 | 127, 2, 4, 8, 16, 32, 127, 0, 100 | 60, 32, 32, 32, 32, 32, 60, 0, 101 | 128, 64, 32, 16, 8, 4, 2, 0, 102 | 60, 4, 4, 4, 4, 4, 60, 0, 103 | 8, 20, 34, 0, 0, 0, 0, 0, 104 | 0, 0, 0, 0, 0, 0, 126, 0, 105 | 24, 8, 16, 0, 0, 0, 0, 0, 106 | 0, 0, 127, 1, 127, 65, 127, 0, 107 | 64, 64, 127, 65, 65, 65, 127, 0, 108 | 0, 0, 127, 64, 64, 64, 127, 0, 109 | 1, 1, 127, 65, 65, 65, 127, 0, 110 | 0, 0, 127, 65, 127, 64, 127, 0, 111 | 31, 16, 16, 124, 16, 16, 16, 0, 112 | 0, 0, 127, 65, 127, 1, 127, 0, 113 | 64, 64, 127, 65, 65, 65, 65, 0, 114 | 16, 0, 16, 16, 16, 16, 16, 0, 115 | 1, 0, 1, 1, 65, 65, 127, 0, 116 | 0, 0, 65, 66, 124, 66, 65, 0, 117 | 0, 0, 120, 8, 8, 8, 127, 0, 118 | 0, 0, 127, 73, 73, 73, 73, 0, 119 | 0, 0, 126, 65, 65, 65, 65, 0, 120 | 0, 0, 127, 65, 65, 65, 127, 0, 121 | 0, 0, 127, 65, 127, 64, 64, 0, 122 | 0, 0, 127, 65, 127, 1, 1, 0, 123 | 0, 0, 65, 66, 124, 64, 64, 0, 124 | 0, 0, 127, 64, 127, 1, 127, 0, 125 | 16, 16, 16, 124, 16, 16, 31, 0, 126 | 0, 0, 65, 65, 65, 65, 127, 0, 127 | 0, 0, 65, 65, 34, 20, 8, 0, 128 | 0, 0, 65, 73, 85, 99, 65, 0, 129 | 0, 0, 66, 36, 24, 36, 66, 0, 130 | 0, 0, 65, 65, 127, 1, 127, 0, 131 | 0, 0, 127, 4, 8, 16, 127, 0, 132 | 12, 16, 16, 96, 16, 16, 12, 0, 133 | 8, 8, 8, 8, 8, 8, 8, 0, 134 | 48, 8, 8, 6, 8, 8, 48, 0, 135 | 50, 76, 0, 0, 0, 0, 0, 0, 136 | 0, 0, 0, 0, 0, 0, 0, 0, 137 | 24, 24, 36, 36, 66, 126, 66, 0, 138 | 62, 32, 60, 34, 34, 34, 60, 0, 139 | 60, 34, 34, 60, 34, 34, 60, 0, 140 | 62, 34, 32, 32, 32, 32, 32, 0, 141 | 60, 36, 36, 36, 36, 126, 66, 0, 142 | 62, 32, 32, 60, 32, 32, 62, 0, 143 | 146, 214, 56, 56, 56, 84, 146, 0, 144 | 28, 34, 2, 12, 2, 34, 28, 0, 145 | 34, 34, 38, 42, 50, 34, 34, 0, 146 | 42, 34, 38, 42, 50, 34, 34, 0, 147 | 34, 36, 40, 48, 40, 36, 34, 0, 148 | 14, 10, 10, 10, 10, 42, 50, 0, 149 | 130, 198, 170, 146, 130, 130, 130, 0, 150 | 34, 34, 34, 62, 34, 34, 34, 0, 151 | 28, 34, 34, 34, 34, 34, 28, 0, 152 | 62, 34, 34, 34, 34, 34, 34, 0, 153 | 60, 34, 34, 34, 60, 32, 32, 0, 154 | 28, 34, 32, 32, 32, 34, 28, 0, 155 | 62, 8, 8, 8, 8, 8, 8, 0, 156 | 66, 66, 36, 36, 24, 72, 48, 0, 157 | 16, 124, 146, 146, 146, 124, 16, 0, 158 | 34, 34, 20, 8, 20, 34, 34, 0, 159 | 36, 36, 36, 36, 36, 36, 62, 2, 160 | 34, 34, 34, 38, 26, 2, 2, 0, 161 | 146, 146, 146, 146, 146, 146, 254, 0, 162 | 146, 146, 146, 146, 146, 146, 254, 2, 163 | 112, 16, 16, 28, 18, 18, 28, 0, 164 | 66, 66, 66, 114, 74, 74, 114, 0, 165 | 16, 16, 16, 28, 18, 18, 28, 0, 166 | 28, 34, 2, 30, 2, 34, 28, 0, 167 | 156, 162, 162, 226, 162, 162, 156, 0, 168 | 30, 34, 34, 30, 10, 18, 34, 0, 169 | 0, 12, 18, 2, 30, 18, 30, 0, 170 | 2, 12, 16, 28, 18, 18, 12, 0, 171 | 0, 28, 18, 28, 18, 18, 28, 0, 172 | 0, 30, 18, 16, 16, 16, 16, 0, 173 | 0, 28, 20, 20, 20, 62, 34, 0, 174 | 0, 12, 18, 30, 16, 18, 12, 0, 175 | 0, 42, 42, 28, 28, 42, 42, 0, 176 | 0, 12, 18, 4, 4, 18, 12, 0, 177 | 0, 18, 22, 22, 26, 26, 18, 0, 178 | 12, 0, 18, 22, 26, 18, 18, 0, 179 | 0, 18, 20, 24, 24, 20, 18, 0, 180 | 0, 14, 10, 10, 10, 26, 26, 0, 181 | 0, 34, 54, 42, 34, 34, 34, 0, 182 | 0, 18, 18, 18, 30, 18, 18, 0, 183 | 0, 12, 18, 18, 18, 18, 12, 0, 184 | 0, 30, 18, 18, 18, 18, 18, 0, 185 | 0, 0, 0, 0, 0, 0, 0, 0, 186 | 0, 0, 0, 0, 0, 0, 0, 0, 187 | 0, 0, 0, 0, 0, 0, 0, 0, 188 | 0, 0, 0, 0, 0, 0, 0, 0, 189 | 0, 0, 0, 0, 0, 0, 0, 0, 190 | 0, 0, 0, 0, 0, 0, 0, 0, 191 | 0, 0, 0, 0, 0, 0, 0, 0, 192 | 0, 0, 0, 0, 0, 0, 0, 0, 193 | 0, 0, 0, 0, 0, 0, 0, 0, 194 | 0, 0, 0, 0, 0, 0, 0, 0, 195 | 0, 0, 0, 0, 0, 0, 0, 0, 196 | 0, 0, 0, 0, 0, 0, 0, 0, 197 | 0, 0, 0, 0, 0, 0, 0, 0, 198 | 0, 0, 0, 0, 0, 0, 0, 0, 199 | 0, 0, 0, 0, 0, 0, 0, 0, 200 | 0, 0, 0, 0, 0, 0, 0, 0, 201 | 0, 0, 0, 0, 0, 0, 0, 0, 202 | 0, 0, 0, 0, 0, 0, 0, 0, 203 | 0, 0, 0, 0, 0, 0, 0, 0, 204 | 0, 0, 0, 0, 0, 0, 0, 0, 205 | 0, 0, 0, 0, 0, 0, 0, 0, 206 | 0, 0, 0, 0, 0, 0, 0, 0, 207 | 0, 0, 0, 0, 0, 0, 0, 0, 208 | 0, 0, 0, 0, 0, 0, 0, 0, 209 | 0, 0, 0, 0, 0, 0, 0, 0, 210 | 0, 0, 0, 0, 0, 0, 0, 0, 211 | 0, 0, 0, 0, 0, 0, 0, 0, 212 | 0, 0, 0, 0, 0, 0, 0, 0, 213 | 0, 0, 0, 0, 0, 0, 0, 0, 214 | 0, 0, 0, 0, 0, 0, 0, 0, 215 | 0, 0, 0, 0, 0, 0, 0, 0, 216 | 0, 0, 0, 0, 0, 0, 0, 0, 217 | 0, 0, 0, 0, 0, 0, 0, 0, 218 | 0, 0, 0, 0, 0, 0, 0, 0, 219 | 0, 0, 0, 0, 0, 0, 0, 0, 220 | 0, 0, 0, 0, 0, 0, 0, 0, 221 | 0, 0, 0, 0, 0, 0, 0, 0, 222 | 0, 0, 0, 0, 0, 0, 0, 0, 223 | 0, 0, 0, 0, 0, 0, 0, 0, 224 | 0, 0, 0, 0, 0, 0, 0, 0, 225 | 0, 0, 0, 0, 0, 0, 0, 0, 226 | 0, 0, 0, 0, 0, 0, 0, 0, 227 | 0, 0, 0, 0, 0, 0, 0, 0, 228 | 0, 0, 0, 0, 0, 0, 0, 0, 229 | 0, 0, 0, 0, 0, 0, 0, 0, 230 | 0, 0, 0, 0, 0, 0, 0, 0, 231 | 0, 0, 0, 0, 0, 0, 0, 0, 232 | 0, 0, 0, 0, 0, 0, 0, 0, 233 | 0, 28, 18, 18, 28, 16, 16, 0, 234 | 0, 12, 18, 16, 16, 18, 12, 0, 235 | 0, 62, 8, 8, 8, 8, 8, 0, 236 | 0, 18, 18, 14, 2, 18, 12, 0, 237 | 0, 28, 42, 42, 42, 28, 8, 0, 238 | 0, 18, 18, 12, 12, 18, 18, 0, 239 | 0, 18, 18, 18, 18, 18, 30, 2, 240 | 0, 18, 18, 18, 14, 2, 2, 0, 241 | 0, 42, 42, 42, 42, 42, 62, 0, 242 | 0, 42, 42, 42, 42, 42, 62, 2, 243 | 0, 56, 8, 12, 10, 10, 12, 0, 244 | 0, 34, 34, 50, 42, 42, 50, 0, 245 | 0, 8, 8, 12, 10, 10, 12, 0, 246 | 0, 12, 18, 2, 6, 18, 12, 0, 247 | 0, 76, 82, 114, 82, 82, 76, 0, 248 | 0, 14, 18, 18, 14, 10, 18, 0, 249 | 20, 0, 62, 32, 60, 32, 62, 0, 250 | 18, 0, 12, 18, 30, 16, 30, 0, 251 | 0, 0, 0, 0, 0, 0, 0, 0, 252 | 0, 0, 0, 0, 0, 0, 0, 0, 253 | 0, 0, 0, 0, 0, 0, 0, 0, 254 | 0, 0, 0, 0, 0, 0, 0, 0, 255 | 0, 0, 0, 0, 0, 0, 0, 0, 256 | 0, 0, 0, 0, 0, 0, 0, 0, 257 | 0, 0, 0, 0, 0, 0, 0, 0, 258 | 0, 0, 0, 0, 0, 0, 0, 0, 259 | 0, 0, 0, 0, 0, 0, 0, 0, 260 | 0, 0, 0, 0, 0, 0, 0, 0, 261 | 0, 0, 0, 0, 0, 0, 0, 0, 262 | 0, 0, 0, 0, 0, 0, 0, 0, 263 | 0, 0, 0, 0, 0, 0, 0, 0, 264 | 0, 0, 0, 0, 0, 0, 0, 0 265 | }; 266 | -------------------------------------------------------------------------------- /psytexx/win_psypattern.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | win_psypattern.cpp - pattern properties (size, channels ...) 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "win_psypattern.h" 9 | #include "win_button.h" 10 | #include "win_text.h" 11 | #include "win_main.h" 12 | #include "win_psychannels.h" 13 | #include "../memory/memory.h" 14 | #include "../time/time.h" 15 | #include "../xm/xm.h" 16 | 17 | int text_bpm; 18 | int text_speed; 19 | int text_patsize; 20 | int text_add; 21 | int text_channels; 22 | 23 | uint psytexx_start_time = 0; 24 | uint play_start_time = 0; 25 | uint playing_time = 0; 26 | 27 | int text_bpm_handler(void *user_data, int text_win, window_manager *wm) 28 | { 29 | pattern_data *data = (pattern_data*)user_data; 30 | 31 | set_bpm( text_get_value( text_win, wm ), &xm ); 32 | 33 | return 0; 34 | } 35 | 36 | int text_speed_handler(void *user_data, int text_win, window_manager *wm) 37 | { 38 | pattern_data *data = (pattern_data*)user_data; 39 | 40 | set_speed( text_get_value( text_win, wm ), &xm ); 41 | 42 | return 0; 43 | } 44 | 45 | int text_patsize_handler(void *user_data, int text_win, window_manager *wm) 46 | { 47 | pattern_data *data = (pattern_data*)user_data; 48 | 49 | module *song = xm.song; 50 | int tablepos = xm.tablepos; 51 | uint16_t patnum = song->patterntable[ tablepos ]; 52 | // Resize pattern: 53 | mem_off(); 54 | resize_pattern( patnum, (uint16_t)text_get_value( text_win, wm ), song->channels, &xm ); 55 | mem_on(); 56 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); //Redraw screen 57 | 58 | return 0; 59 | } 60 | 61 | int text_add_handler(void *user_data, int text_win, window_manager *wm) 62 | { 63 | pattern_data *data = (pattern_data*)user_data; 64 | 65 | return 0; 66 | } 67 | 68 | int text_channels_handler(void *user_data, int text_win, window_manager *wm) 69 | { 70 | pattern_data *data = (pattern_data*)user_data; 71 | 72 | //New number of channels: 73 | uint16_t channels = (uint16_t)text_get_value( text_win, wm ); 74 | 75 | module *song = xm.song; 76 | 77 | //Resize all patterns: 78 | for( uint16_t a = 0; a < 256; a++ ) 79 | { 80 | pattern *pat = song->patterns[ a ]; 81 | if( pat ) 82 | { 83 | // Resize pattern: 84 | mem_off(); 85 | resize_pattern( a, pat->rows, channels, &xm ); 86 | mem_on(); 87 | } 88 | } 89 | 90 | song->channels = channels; //Set new number 91 | 92 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); //Redraw screen 93 | 94 | return 0; 95 | } 96 | 97 | void psypattern_redraw_channels( int win_num, window_manager *wm ) 98 | { 99 | window *win = wm->windows[ win_num ]; //Our window 100 | pattern_data *data = (pattern_data*)win->data; 101 | channels_redraw( data->channels, wm ); 102 | } 103 | 104 | void get_text_time( char *dest, int h, int m, int s ) 105 | { 106 | dest[ 0 ] = 0; 107 | char temp2[3]; 108 | int val, val10; 109 | val = val10 = h; val10 = val / 10; 110 | temp2[ 0 ] = (char)val10 + '0'; 111 | temp2[ 1 ] = (char)val - ( (char)val10 * 10 ) + '0'; 112 | temp2[ 2 ] = 0; 113 | mem_strcat( dest, temp2 ); 114 | mem_strcat( dest, ":" ); 115 | val = val10 = m; val10 = val / 10; 116 | temp2[ 0 ] = (char)val10 + '0'; 117 | temp2[ 1 ] = (char)val - ( (char)val10 * 10 ) + '0'; 118 | mem_strcat( dest, temp2 ); 119 | mem_strcat( dest, ":" ); 120 | val = val10 = s; val10 = val / 10; 121 | temp2[ 0 ] = (char)val10 + '0'; 122 | temp2[ 1 ] = (char)val - ( (char)val10 * 10 ) + '0'; 123 | mem_strcat( dest, temp2 ); 124 | } 125 | 126 | //Get psytexx working time: 127 | void psypattern_draw_time( int win_num, window_manager *wm ) 128 | { 129 | window *win = wm->windows[ win_num ]; //Our window 130 | pattern_data *data = (pattern_data*)win->data; 131 | 132 | //Current time: 133 | char temp2[ 16 ]; 134 | char temp3[ 64 ]; 135 | temp3[ 0 ] = 0; 136 | get_text_time( temp2, time_hours(), time_minutes(), time_seconds() ); 137 | mem_strcat( temp3, temp2 ); 138 | 139 | //playing time: 140 | if( xm.status > 0 ) 141 | { 142 | playing_time = time_ticks() - play_start_time; 143 | playing_time /= time_ticks_per_second(); 144 | } 145 | get_text_time( temp2, playing_time / 3600, ( playing_time / 60 ) % 60, playing_time % 60 ); 146 | mem_strcat( temp3, " " ); 147 | mem_strcat( temp3, temp2 ); 148 | 149 | matrix_draw_box( win_num, 0, 5, 44, 1, win->color, wm ); 150 | matrix_draw_string( win_num, 0, 5, ATR_SHADOW, temp3, wm ); 151 | } 152 | 153 | int pattern_handler(wm_event *evt, window_manager *wm) 154 | { 155 | window *win = wm->windows[ evt->event_win ]; //Our window 156 | pattern_data *data = (pattern_data*)win->data; 157 | 158 | switch( evt->event_type ) 159 | { 160 | case EVT_AFTERCREATE: 161 | win->data = mem_new( HEAP_DYNAMIC, sizeof(pattern_data), "pattern properties" ); 162 | 163 | //Init data: 164 | data = (pattern_data*)win->data; 165 | 166 | data->this_window = evt->event_win; 167 | 168 | //Create buttons: 169 | NEW_TEXT_SIZE = 8; 170 | text_bpm = 171 | data->text_bpm = create_window( "bpm", 0, 1, 7, 2, wm->colors[6], 1, evt->event_win, &text_handler, wm ); 172 | text_set_numerical( data->text_bpm, 1, wm ); 173 | text_set_caption( data->text_bpm, "BPM", wm ); 174 | text_set_value( data->text_bpm, 125, wm ); 175 | text_set_bounds( data->text_bpm, 0, 255, wm ); 176 | text_set_handler( &text_bpm_handler, (void*)data, data->text_bpm, wm ); 177 | 178 | NEW_TEXT_SIZE = 8; 179 | text_speed = 180 | data->text_speed = create_window( "tpl", 0, 2+1, 7, 2, wm->colors[6], 1, evt->event_win, &text_handler, wm ); 181 | text_set_numerical( data->text_speed, 1, wm ); 182 | text_set_caption( data->text_speed, "TPL", wm ); 183 | text_set_value( data->text_speed, 6, wm ); 184 | text_set_bounds( data->text_speed, 0, 31, wm ); 185 | text_set_handler( &text_speed_handler, (void*)data, data->text_speed, wm ); 186 | 187 | NEW_TEXT_SIZE = 8; 188 | text_patsize = 189 | data->text_patsize = create_window( "psize", 7 + 1, 1, 7, 2, wm->colors[6], 1, evt->event_win, &text_handler, wm ); 190 | text_set_numerical( data->text_patsize, 1, wm ); 191 | text_set_caption( data->text_patsize, "PSZ", wm ); 192 | text_set_value( data->text_patsize, 64, wm ); 193 | text_set_bounds( data->text_patsize, 1, 512, wm ); 194 | text_set_handler( &text_patsize_handler, (void*)data, data->text_patsize, wm ); 195 | 196 | NEW_TEXT_SIZE = 8; 197 | text_add = 198 | data->text_add = create_window( "add", 7 + 1, 2+1, 7, 2, wm->colors[6], 1, evt->event_win, &text_handler, wm ); 199 | text_set_numerical( data->text_add, 1, wm ); 200 | text_set_caption( data->text_add, "ADD", wm ); 201 | text_set_value( data->text_add, 1, wm ); 202 | text_set_bounds( data->text_add, 1, 32, wm ); 203 | text_set_handler( &text_add_handler, (void*)data, data->text_add, wm ); 204 | 205 | NEW_TEXT_SIZE = 8; 206 | text_channels = 207 | data->text_channels = create_window( "channels", 7+1+7+1, 1, 6, 2, wm->colors[6], 1, evt->event_win, &text_handler, wm ); 208 | text_set_numerical( data->text_channels, 1, wm ); 209 | text_set_caption( data->text_channels, "CHN.", wm ); 210 | text_set_value( data->text_channels, 8, wm ); 211 | text_set_bounds( data->text_channels, 1, MAX_CHANNELS, wm ); 212 | text_set_handler( &text_channels_handler, (void*)data, data->text_channels, wm ); 213 | 214 | #ifndef NONPALM 215 | data->channels = create_window( "scopes", 7+1+7+1+7, 1, 30, 4, wm->colors[15], 1, evt->event_win, &channels_handler, wm ); 216 | #else 217 | data->channels = create_window( "scopes", 7+1+7+1+7, 1, 40, 4, wm->colors[15], 1, evt->event_win, &channels_handler, wm ); 218 | #endif 219 | 220 | create_scrollarea( evt->event_win, wm ); 221 | break; 222 | 223 | case EVT_BEFORECLOSE: 224 | if( win->data ) mem_free( win->data ); 225 | break; 226 | 227 | case EVT_SHOW: 228 | //Show window: 229 | win->visible = 1; //Make it visible 230 | send_event(evt->event_win, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm); //Send DRAW event to all childs 231 | break; 232 | 233 | case EVT_HIDE: 234 | win->visible = 0; 235 | break; 236 | 237 | case EVT_DRAW: 238 | //Draw window (if it's visible) 239 | if( win->visible ) 240 | { 241 | draw_window_touch_area( evt->event_win, wm ); 242 | draw_window_box( evt->event_win, wm ); //draw window box 243 | psypattern_draw_time( evt->event_win, wm ); 244 | } 245 | break; 246 | 247 | case EVT_REDRAW: 248 | //Redraw window (if it's visible) 249 | if( win->visible ) 250 | { 251 | draw_window_box( evt->event_win, wm ); //draw window box 252 | psypattern_draw_time( evt->event_win, wm ); 253 | } 254 | break; 255 | } 256 | return 0; 257 | } 258 | -------------------------------------------------------------------------------- /psytexx/win_dialog.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | win_dialog.cpp - dialog handler 3 | This file is part of the PsyTexx2. 4 | Copyright (C) 2002 - 2024 Alexander Zolotov 5 | WarmPlace.ru 6 | */ 7 | 8 | #include "win_main.h" 9 | #include "win_button.h" 10 | #include "win_dialog.h" 11 | 12 | int dialog_visible = 0; 13 | 14 | int ok_button_handler( void *user_data, int button_win, window_manager *wm ) 15 | { 16 | dialog_data *data = (dialog_data*)user_data; 17 | send_event( data->this_window, EVT_HIDE, 0, 0, 0, 0, MODE_CHILDS, wm ); 18 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 19 | if( data->handler ) 20 | data->handler( data->user_data, 1, wm ); 21 | wm->mouse_win = data->old_focus_window; 22 | return 0; 23 | } 24 | 25 | int cancel_button_handler( void *user_data, int button_win, window_manager *wm ) 26 | { 27 | dialog_data *data = (dialog_data*)user_data; 28 | send_event( data->this_window, EVT_HIDE, 0, 0, 0, 0, MODE_CHILDS, wm ); 29 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 30 | if( data->handler ) 31 | data->handler( data->user_data, 0, wm ); 32 | wm->mouse_win = data->old_focus_window; 33 | return 0; 34 | } 35 | 36 | void start_dialog( const char *text, const char *ok, const char *cancel, 37 | void (*handler)(void*,int,window_manager*), void *user_data, 38 | int win_num, window_manager *wm ) 39 | { 40 | window *win = wm->windows[ win_num ]; //Our window 41 | dialog_data *data = (dialog_data*)win->data; 42 | 43 | button_set_name( ok, data->button_ok, wm ); 44 | button_set_name( cancel, data->button_cancel, wm ); 45 | data->handler = handler; 46 | data->user_data = user_data; 47 | 48 | int len = 0; 49 | for(;;) 50 | { 51 | if( text[len++] == 0 ) break; 52 | } 53 | data->title_len = len; 54 | data->title = text; 55 | 56 | send_event( win_num, EVT_SHOW, 0, 0, 0, 0, MODE_CHILDS, wm ); 57 | //Set focus to this window: 58 | data->old_focus_window = wm->mouse_win; 59 | wm->mouse_win = win_num; 60 | } 61 | 62 | void standard_dialog_handler( void *user_data, int button, window_manager *wm ) 63 | { 64 | int *res = (int*)user_data; 65 | if( button == 1 ) 66 | { 67 | //Ok: 68 | *res = 1; 69 | } 70 | else 71 | { 72 | //Cancel: 73 | *res = 0; 74 | } 75 | } 76 | 77 | int start_dialog_blocked( 78 | const char *text, const char *ok, const char *cancel, 79 | window_manager *wm ) 80 | { 81 | int result = 5; 82 | window *win = wm->windows[ win_dialog ]; //Our window 83 | dialog_data *data = (dialog_data*)win->data; 84 | 85 | button_set_name( ok, data->button_ok, wm ); 86 | button_set_name( cancel, data->button_cancel, wm ); 87 | data->handler = &standard_dialog_handler; 88 | data->user_data = &result; 89 | 90 | int len = 0; 91 | for(;;) 92 | { 93 | if( text[len++] == 0 ) break; 94 | } 95 | data->title_len = len; 96 | data->title = text; 97 | 98 | send_event( win_dialog, EVT_SHOW, 0, 0, 0, 0, MODE_CHILDS, wm ); 99 | //Set focus to this window: 100 | data->old_focus_window = wm->mouse_win; 101 | wm->mouse_win = win_dialog; 102 | 103 | while( result == 5 ) 104 | { 105 | if( wm->events_count ) 106 | { 107 | int ev_num; 108 | for( ev_num = 0; ev_num < wm->events_count; ev_num++ ) 109 | { 110 | wm_event *evt = wm->events[ ( wm->event_pnt + ev_num ) & MAX_EVENT ]; 111 | if( evt ) 112 | if( evt->event_win ) 113 | if( evt->event_type == EVT_BUTTONDOWN && ( evt->button & 3 ) ) 114 | if( evt->event_win != win_dialog && 115 | evt->event_win != data->button_cancel && 116 | evt->event_win != data->button_ok ) 117 | { 118 | //Was a click on another window: 119 | send_event( win_dialog, EVT_HIDE, 0, 0, 0, 0, MODE_CHILDS, wm ); 120 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 121 | //wm->mouse_win = data->old_focus_window; 122 | result = -1; 123 | //break; 124 | } 125 | } 126 | } 127 | event_loop( wm, 0 ); 128 | } 129 | return result; 130 | } 131 | 132 | int dialog_handler( wm_event *evt, window_manager *wm ) 133 | { 134 | window *win = wm->windows[ evt->event_win ]; //Our window 135 | dialog_data *data = (dialog_data*)win->data; 136 | int handled = 0; 137 | 138 | switch( evt->event_type ) 139 | { 140 | case EVT_AFTERCREATE: 141 | win->data = mem_new( HEAP_DYNAMIC, sizeof(dialog_data), "dialog data" ); 142 | //Init data: 143 | data = (dialog_data*)win->data; 144 | 145 | data->this_window = evt->event_win; 146 | 147 | data->current_button = 0; 148 | 149 | data->button_ok = create_window( "okbutton", 150 | win->x_size/2 - 9, win->y_size/2, 151 | 8, 2, get_color( 255, 128, 0 ), 1, evt->event_win, &button_handler, wm ); 152 | set_window_string_controls( data->button_ok, "50%-9", "50%", "50%-1", "50%+2", wm ); 153 | button_set_name( "OK", data->button_ok, wm ); 154 | button_set_handler( &ok_button_handler, (void*)data, data->button_ok, wm ); 155 | 156 | data->button_cancel = create_window( "cancelbutton", 157 | win->x_size/2 + 1, win->y_size/2, 158 | 8, 2, wm->colors[6], 1, evt->event_win, &button_handler, wm ); 159 | set_window_string_controls( data->button_cancel, "50%+1", "50%", "50%+9", "50%+2", wm ); 160 | button_set_name( "CANCEL", data->button_cancel, wm ); 161 | button_set_handler( &cancel_button_handler, (void*)data, data->button_cancel, wm ); 162 | 163 | data->handler = 0; 164 | break; 165 | 166 | case EVT_BEFORECLOSE: 167 | if( win->data ) mem_free( win->data ); 168 | break; 169 | case EVT_SHOW: 170 | //Show window: 171 | win->visible = 1; //Make it visible 172 | dialog_visible = 1; 173 | data->current_button = 0; 174 | button_set_color( get_color( 255, 128, 0 ), data->button_ok, wm ); 175 | button_set_color( wm->colors[ 6 ], data->button_cancel, wm ); 176 | send_event(evt->event_win, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm); //Send DRAW event to all childs 177 | break; 178 | case EVT_HIDE: 179 | win->visible = 0; 180 | dialog_visible = 0; 181 | break; 182 | case EVT_DRAW: 183 | //Draw window (if it's visible) 184 | if( win->visible ) 185 | { 186 | draw_window_touch_area( evt->event_win, wm ); 187 | draw_window_box( evt->event_win, wm ); //draw window box 188 | draw_string( evt->event_win, 189 | ( (win->x_size*wm->char_x) - (data->title_len*wm->char_x) ) >> 1, 190 | (win->y_size*wm->char_y) / 2 - wm->char_y*2, 191 | 0, data->title, wm ); 192 | draw_rectangle( evt->event_win, 0, 0, win->x_size * wm->char_x, win->y_size * wm->char_y, get_color( 0, 0, 0 ), wm ); 193 | } 194 | break; 195 | case EVT_REDRAW: 196 | //Redraw window (if it's visible) 197 | if( win->visible ) 198 | { 199 | draw_window_box( evt->event_win, wm ); //draw window box 200 | draw_string( evt->event_win, 201 | ( (win->x_size*wm->char_x) - (data->title_len*wm->char_x) ) >> 1, 202 | (win->y_size*wm->char_y) / 2 - wm->char_y*2, 203 | 0, data->title, wm ); 204 | draw_rectangle( evt->event_win, 0, 0, win->x_size * wm->char_x, win->y_size * wm->char_y, get_color( 0, 0, 0 ), wm ); 205 | } 206 | break; 207 | case EVT_BUTTONDOWN: 208 | handled = 1; 209 | if( evt->button >> 3 ) 210 | { 211 | switch( evt->button >> 3 ) 212 | { 213 | case 'y': case 'Y': 214 | send_event( data->this_window, EVT_HIDE, 0, 0, 0, 0, MODE_CHILDS, wm ); 215 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 216 | if( data->handler ) 217 | data->handler( data->user_data, 1, wm ); 218 | wm->mouse_win = data->old_focus_window; 219 | handled = 1; 220 | break; 221 | 222 | case 'n': case 'N': case KEY_ESCAPE: 223 | send_event( data->this_window, EVT_HIDE, 0, 0, 0, 0, MODE_CHILDS, wm ); 224 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 225 | if( data->handler ) 226 | data->handler( data->user_data, 0, wm ); 227 | wm->mouse_win = data->old_focus_window; 228 | handled = 1; 229 | break; 230 | 231 | case KEY_TAB: case KEY_LEFT: case KEY_RIGHT: 232 | data->current_button ^= 1; 233 | if( data->current_button == 0 ) 234 | { 235 | button_set_color( get_color( 255, 128, 0 ), data->button_ok, wm ); 236 | button_set_color( wm->colors[ 6 ], data->button_cancel, wm ); 237 | } 238 | else 239 | { 240 | button_set_color( get_color( 255, 128, 0 ), data->button_cancel, wm ); 241 | button_set_color( wm->colors[ 6 ], data->button_ok, wm ); 242 | } 243 | send_event( data->this_window, EVT_REDRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 244 | handled = 1; 245 | break; 246 | 247 | case KEY_ENTER: case ' ': 248 | send_event( data->this_window, EVT_HIDE, 0, 0, 0, 0, MODE_CHILDS, wm ); 249 | send_event( 0, EVT_DRAW, 0, 0, 0, 0, MODE_CHILDS, wm ); 250 | if( data->current_button == 0 ) 251 | { 252 | if( data->handler ) 253 | data->handler( data->user_data, 1, wm ); 254 | } 255 | else 256 | { 257 | if( data->handler ) 258 | data->handler( data->user_data, 0, wm ); 259 | } 260 | wm->mouse_win = data->old_focus_window; 261 | handled = 1; 262 | break; 263 | } 264 | } 265 | break; 266 | } 267 | return handled; 268 | } 269 | -------------------------------------------------------------------------------- /MAKE/palmos/arm_starter.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | SunDog ARM ELF starter for PalmOS 3 | by Alexander Zolotov / nightradio@gmail.com / WarmPlace.ru 4 | This file is public domain 5 | */ 6 | 7 | //WARNING !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 8 | //This version can't execute ARM-code with functions, declared as "static" 9 | //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!! 10 | 11 | #include 12 | #include 13 | #include 14 | #include "PceNativeCall.h" 15 | 16 | #define ByteSwap16(n) ( ((((unsigned long) n) <<8 ) & 0xFF00) | \ 17 | ((((unsigned long) n) >>8 ) & 0x00FF) ) 18 | 19 | #define ByteSwap32(n) ( ((((unsigned long) n) << 24 ) & 0xFF000000) | \ 20 | ((((unsigned long) n) << 8 ) & 0x00FF0000) | \ 21 | ((((unsigned long) n) >> 8 ) & 0x0000FF00) | \ 22 | ((((unsigned long) n) >> 24 ) & 0x000000FF) ) 23 | 24 | struct ARM_INFO 25 | { 26 | void* GLOBALS; 27 | void* GOT; 28 | void* FORMHANDLER; 29 | long ID; 30 | long* new_screen_size; 31 | }; 32 | 33 | long g_new_screen_size[ 4 ] = { 0, 0, 0, 0 }; 34 | 35 | FormPtr gpForm; 36 | 37 | Boolean FormHandler( EventPtr event ) 38 | { 39 | Err err; 40 | UInt32 pinMgrVersion; 41 | RectangleType bounds; 42 | Boolean handled = false; 43 | switch( event->eType ) 44 | { 45 | case frmOpenEvent: 46 | gpForm = FrmGetActiveForm(); 47 | 48 | err = FtrGet( pinCreator, pinFtrAPIVersion, &pinMgrVersion ); 49 | if ( !err && pinMgrVersion != pinAPIVersion1_0 ) 50 | { 51 | FrmSetDIAPolicyAttr( gpForm, frmDIAPolicyCustom ); 52 | PINSetInputTriggerState( pinInputTriggerEnabled ); 53 | //PINSetInputAreaState( 2 ); //pinInputAreaHide 54 | //StatHide(); //Hide control panel 55 | } 56 | else 57 | { //No pinAPI: (TungstenT for example) 58 | } 59 | 60 | WinGetBounds( WinGetDisplayWindow(), &bounds ); 61 | g_new_screen_size[ 0 ] = ByteSwap32( (long)bounds.topLeft.x ); 62 | g_new_screen_size[ 1 ] = ByteSwap32( (long)bounds.topLeft.y ); 63 | g_new_screen_size[ 2 ] = ByteSwap32( (long)bounds.extent.x ); 64 | g_new_screen_size[ 3 ] = ByteSwap32( (long)bounds.extent.y ); 65 | 66 | FrmDrawForm( gpForm ); 67 | 68 | handled = true; 69 | 70 | break; 71 | 72 | case winDisplayChangedEvent: 73 | WinGetBounds( WinGetDisplayWindow(), &bounds ); 74 | WinSetBounds( WinGetActiveWindow(), &bounds ); 75 | g_new_screen_size[ 0 ] = ByteSwap32( (long)bounds.topLeft.x ); 76 | g_new_screen_size[ 1 ] = ByteSwap32( (long)bounds.topLeft.y ); 77 | g_new_screen_size[ 2 ] = ByteSwap32( (long)bounds.extent.x ); 78 | g_new_screen_size[ 3 ] = ByteSwap32( (long)bounds.extent.y ); 79 | handled = true; 80 | break; 81 | 82 | case frmCloseEvent: 83 | FrmEraseForm( gpForm ); 84 | FrmDeleteForm( gpForm ); 85 | gpForm = 0; 86 | handled = true; 87 | break; 88 | } 89 | return handled; 90 | } 91 | 92 | #define memNewChunkFlagNonMovable 0x0200 93 | #define memNewChunkFlagAllowLarge 0x1000 94 | SysAppInfoPtr ai1, ai2, appInfo; 95 | SysAppInfoPtr SysGetAppInfo( SysAppInfoPtr* rootAppPP, SysAppInfoPtr* actionCodeAppPP ) SYS_TRAP( sysTrapSysUIBusy ); 96 | 97 | void* bmem_new_ext( unsigned long size ) 98 | { 99 | unsigned short ownID = appInfo->memOwnerID; 100 | return MemChunkNew( MemHeapID( 0, 0 ), size, ownID | memNewChunkFlagNonMovable | memNewChunkFlagAllowLarge ); 101 | } 102 | 103 | void bmem_free( void* ptr ) 104 | { 105 | MemPtrFree( ptr ); 106 | } 107 | 108 | void start_arm_code( void ) 109 | { 110 | ARM_INFO arm_info; 111 | unsigned long* text_section; //Main ARM code 112 | unsigned long* section2; //Data + Rel + Got 113 | unsigned long* got_section; //Global offset table: offset = rel[ got[ var number ] ]; 114 | unsigned char* data_section; //Binary data of the ELF 115 | unsigned long* rel_section; //.rel section 116 | 117 | MemHandle mem_handle_r; 118 | MemHandle mem_handle_d[ 16 ]; 119 | unsigned long mem_handle_d_size[ 16 ]; 120 | MemHandle mem_handle_g; 121 | MemHandle mem_handle_c[ 16 ]; 122 | unsigned long arm_size[ 16 ]; 123 | unsigned long xtra; 124 | MemHandle mem_handle; 125 | 126 | // GET REL SECTION: 127 | mem_handle_r = DmGetResource( 'armr', 0 ); 128 | long rel_size = MemHandleSize( mem_handle_r ); 129 | long rxtra = 4 - (rel_size & 3); if( rxtra == 4 ) rxtra = 0; 130 | 131 | // GET DATA SECTIONS: 132 | unsigned long data_size = 0; 133 | int dr; 134 | for( dr = 0; dr < 16; dr++ ) 135 | { 136 | mem_handle_d[ dr ] = DmGetResource( 'armd', dr ); 137 | if( mem_handle_d[ dr ] ) 138 | { 139 | mem_handle_d_size[ dr ] = MemHandleSize( mem_handle_d[ dr ] ); 140 | } 141 | else 142 | { 143 | mem_handle_d_size[ dr ] = 0; 144 | } 145 | data_size += mem_handle_d_size[ dr ]; 146 | } 147 | unsigned long dxtra = 4 - (data_size & 3); if( dxtra == 4 ) dxtra = 0; 148 | 149 | // GET GOT SECTION: 150 | mem_handle_g = DmGetResource( 'armg', 0 ); 151 | unsigned long got_size = MemHandleSize( mem_handle_g ); 152 | unsigned long gxtra = 4 - (got_size & 3); if( gxtra == 4 ) gxtra = 0; 153 | 154 | // GET CODE SECTIONS: 155 | long code_size = 0; 156 | int cr; 157 | for( cr = 0; cr < 16; cr++ ) 158 | { 159 | mem_handle_c[ cr ] = DmGetResource( 'armc', cr ); 160 | if( mem_handle_c[ cr ] ) 161 | { 162 | arm_size[ cr ] = MemHandleSize( mem_handle_c[ cr ] ); 163 | } 164 | else 165 | { 166 | arm_size[ cr ] = 0; 167 | } 168 | code_size += arm_size[ cr ]; 169 | } 170 | xtra = 4 - ( code_size & 3 ); if( xtra == 4 ) xtra = 0; 171 | 172 | // CREATE ELF BUFFER: 173 | text_section = (unsigned long*)bmem_new_ext( code_size ); 174 | section2 = (unsigned long*)bmem_new_ext( 175 | data_size + dxtra + 176 | rel_size + rxtra + 177 | got_size + gxtra 178 | ); 179 | 180 | // COPY ALL SECTIONS TO THE BUFFER: 181 | long offset = 0; 182 | for( cr = 0; cr < 16; cr++ ) 183 | { 184 | if( arm_size[ cr ] ) 185 | { 186 | MemMove( text_section + offset, MemHandleLock( mem_handle_c[ cr ] ), arm_size[ cr ] ); 187 | offset += arm_size[ cr ] / 4; 188 | } 189 | } 190 | offset = 0; 191 | for( dr = 0; dr < 16; dr++ ) 192 | { 193 | if( mem_handle_d_size[ dr ] ) 194 | { 195 | MemMove( section2 + offset, MemHandleLock( mem_handle_d[ dr ] ), mem_handle_d_size[ dr ] ); 196 | offset += mem_handle_d_size[ dr ] / 4; 197 | } 198 | } 199 | MemMove( section2+((data_size+dxtra)/4), MemHandleLock( mem_handle_r ), rel_size + rxtra ); 200 | MemMove( section2+((data_size+dxtra)/4)+((rel_size+rxtra)/4), MemHandleLock( mem_handle_g ), got_size + gxtra ); 201 | 202 | // CLOSE RESOURCES: 203 | MemHandleUnlock( mem_handle_r ); 204 | MemHandleUnlock( mem_handle_g ); 205 | for( cr = 0; cr < 16; cr++ ) 206 | { 207 | if( mem_handle_c[ cr ] ) 208 | { 209 | MemHandleUnlock( mem_handle_c[ cr ] ); 210 | DmReleaseResource( mem_handle_c[ cr ] ); 211 | } 212 | if( mem_handle_d[ cr ] ) 213 | { 214 | MemHandleUnlock( mem_handle_d[ cr ] ); 215 | DmReleaseResource( mem_handle_d[ cr ] ); 216 | } 217 | } 218 | DmReleaseResource( mem_handle_r ); 219 | DmReleaseResource( mem_handle_g ); 220 | 221 | // FIXING GOT and RELOCATION REFERENCES : 222 | rel_section = section2+((data_size+dxtra)/4); 223 | got_section = section2+((data_size+dxtra)/4)+((rel_size+rxtra)/4); 224 | unsigned long a, res; 225 | for( a = 0; a < got_size / 4; a++ ) 226 | { 227 | res = ByteSwap32( got_section[ a ] ); 228 | if( res < code_size ) 229 | { 230 | res += (unsigned long)text_section; 231 | } 232 | else 233 | { 234 | if( res >= code_size ) 235 | { 236 | res -= code_size; 237 | res += (unsigned long)section2; 238 | } 239 | } 240 | got_section[ a ] = ByteSwap32( res ); 241 | } 242 | for( a = 0; a < rel_size / 4; a++ ) 243 | { 244 | res = ByteSwap32( rel_section[ a ] ); 245 | if( res != 0 ) 246 | { 247 | if( res < code_size ) 248 | { 249 | res += (unsigned long)text_section; 250 | } 251 | else 252 | { 253 | if( res >= code_size ) 254 | { 255 | res -= code_size; 256 | res += (unsigned long)section2; 257 | } 258 | } 259 | rel_section[ a ] = ByteSwap32( res ); 260 | } 261 | } 262 | unsigned long* real_got = section2+((data_size+dxtra)/4)+((rel_size+rxtra)/4); 263 | 264 | // START ARM CODE : 265 | WinDrawChars( "SUNDOG ARM STARTER " __DATE__ " ", 32, 10, 0 ); 266 | arm_info.GLOBALS = (void*)ByteSwap32( text_section ); 267 | arm_info.GOT = (void*)ByteSwap32( real_got ); 268 | arm_info.ID = (long)ByteSwap32( appInfo->memOwnerID ); 269 | arm_info.FORMHANDLER = (void*)ByteSwap32( &FormHandler ); 270 | arm_info.new_screen_size = (long*)ByteSwap32( &g_new_screen_size ); 271 | res = PceNativeCall( (NativeFuncType*)text_section, &arm_info ); 272 | 273 | // FREE DATA : 274 | bmem_free( text_section ); 275 | bmem_free( section2 ); 276 | } 277 | 278 | const char* g_filetypes[] = 279 | { 280 | ".wav", "/AUDIO/", 281 | ".wave", "/AUDIO/", 282 | ".xi", "/AUDIO/", 283 | ".sunvox", "/MUSIC/", 284 | ".xm", "/MUSIC/", 285 | ".mod", "/MUSIC/", 286 | "~" 287 | }; 288 | 289 | UInt32 PilotMain( UInt16 launchCode, void* cmdPBP, UInt16 launchFlags ) 290 | { 291 | if( launchCode == sysAppLaunchCmdNormalLaunch ) 292 | { 293 | appInfo = SysGetAppInfo( &ai1, &ai2 ); 294 | 295 | int fp = 0; 296 | while( 1 ) 297 | { 298 | if( g_filetypes[ fp ][ 0 ] == '~' ) break; 299 | VFSRegisterDefaultDirectory( g_filetypes[ fp ], expMediaType_Any, g_filetypes[ fp + 1 ] ); 300 | fp += 2; 301 | } 302 | 303 | start_arm_code(); 304 | } 305 | return 0; 306 | } 307 | --------------------------------------------------------------------------------