2614 lines
84 KiB
Plaintext
2614 lines
84 KiB
Plaintext
# This code is based on GemZ by gemini however it is not his responsibily
|
||
#
|
||
# If there are any errors contact [NuKe]! !!!!NOT!!!! gemini!
|
||
#
|
||
# All credits are stated (if not...they are most likely gemini)
|
||
|
||
^fset FORMAT_XTERM_TITLE [$0][$2] $5-
|
||
|
||
^set COMMENT_BREAKAGE on
|
||
^set JOIN_NEW_WINDOW on
|
||
^set JOIN_NEW_WINDOW_TYPE create double on
|
||
^set QUERY_NEW_WINDOW on
|
||
^set QUERY_NEW_WINDOW_TYPE create
|
||
^set WINDOW_DESTROY_PART on
|
||
^set SERVER_GROUPS on
|
||
|
||
@ actionsfile = [$IRCLIB()/script/actplug.gmz]
|
||
@ loadacts = [NO]
|
||
@ ctcpsound = [OFF]
|
||
@ ctcpsndreq = [OFF]
|
||
@ EXEDIR = [~]
|
||
@ sounddir = [$EXEDIR/sounds]
|
||
@ SOUND_PATH = [$EXEDIR/sounds ~ ~/sounds]
|
||
@ gz.sounds = 1
|
||
|
||
# Echo Strings
|
||
^assign gemz.act *
|
||
^assign gemz.str .gz.
|
||
^assign gemz.usage ***
|
||
^eval ^assign gemzov.str \\[\$bgrn\ov${cl}\\]\
|
||
alias gecho xecho -b -level crap $*
|
||
alias gbecho xecho -b -level crap $*
|
||
alias gbecho xecho -b -level crap $*
|
||
alias gtecho xecho -b -target $0 $1-
|
||
alias gtbecho xecho -b -target $0 $1-
|
||
alias gtbecho xecho -b $1-
|
||
alias gaecho xecho -b -level crap $*
|
||
alias gnecho xecho -b -level crap $*
|
||
alias guecho xecho -b -level crap gemz.usage $*
|
||
|
||
@ NUMKICK = [7]
|
||
@ kick.0 = [uh, huh huh... uh... yew suck, or something]
|
||
@ kick.1 = [meep meep!]
|
||
@ kick.2 = [bork bork bork bork]
|
||
@ kick.3 = [oops, silly me, that's the wrong key]
|
||
@ kick.4 = [nostalgia kick: Roadkill splattered all over the infobahn]
|
||
@ kick.5 = [nostalgia kick: CDA VIOLATION]
|
||
@ kick.6 = [If anybody gets funk'd its gun' be U!]
|
||
|
||
#----------------------------Kicks-----------------------------#
|
||
alias bkk {/k $0 BurgerKingKick - You get it my way}
|
||
alias mck {/k $0 McKick: You Want Fries with that?}
|
||
alias mcdk {/k $0 McKick: Have you had your break today?!?}
|
||
alias tbk {/k $0 TacoBellKick: Make a run for the border}
|
||
alias cjk {/k $0 CarlsJrKick: If it don't get all over your face, you don't belong in this place}
|
||
alias jbk {/k $0 JackInTheBoxKick: Jacks Back!!}
|
||
alias kfck {/k $0 KentuckyFriedKick: Original Recipe or Extra Crispy?}
|
||
alias kt {/k $0 Kick Toy (tm)}
|
||
alias tkl {/k $0 TaeKwonLeapKick}
|
||
alias gk {/k $0 [GreetKick] Hello to you too!}
|
||
alias wk {/k $0 woikick}
|
||
|
||
alias save {
|
||
if (fexist(~/menu.sav) != -1) {
|
||
@ unlink(~/menu.sav)
|
||
}
|
||
@ outfile = open(~/menu.sav W)
|
||
# gecho Saving menu.bx settings...
|
||
@ write($outfile //^assign ctcpsound $ctcpsound)
|
||
@ write($outfile //^assign loadacts $loadacts)
|
||
@ write($outfile //^assign ctcpsndreq $ctcpsndreq)
|
||
@ write($outfile //^assign SOUND_PATH $SOUND_PATH)
|
||
@ write($outfile //^assign sounddir $sounddir)
|
||
@ write($outfile //^assign actionsfile $actionsfile)
|
||
@ close($outfile)
|
||
//save
|
||
}
|
||
|
||
#
|
||
# This code courtesy of mikh
|
||
#
|
||
|
||
alias searchpath {
|
||
fe ($1-) bleah {
|
||
if (file.exist($bleah/$0)) { return $bleah/$0 }
|
||
}
|
||
return 0
|
||
}
|
||
|
||
### returns 1 if we have file $* for playing, path is stripped from parameter
|
||
### so you can safely pass full qualified filenames here, if file exist,
|
||
### ctcpsnd.fname variable will contain full path to the file, which can
|
||
### be passed to mmpm.playfile or mmpm.playfile2
|
||
|
||
alias ctcpsnd.havefile {
|
||
@ctcpsnd.fname = searchpath($file.sanspath($*) $SOUND_PATH)
|
||
@function_return = file.exist($ctcpsnd.fname)
|
||
}
|
||
|
||
### should be called if you requested a file from someone, and expect dcc
|
||
### send to happen
|
||
### $0 == file name
|
||
alias ctcpsnd.requested {
|
||
@ctcpsnd[$file.sanspath($*)] = time()
|
||
}
|
||
|
||
### this function returns if we already have this file requested from someone
|
||
### it returns time since we requested file, or 10000 if we did not requested
|
||
### such file, so if (ctcpsnd.isrequested(file.wav) > 30) will check if
|
||
### file was requested longer then 30 seconds ago, or not requested at all
|
||
|
||
alias ctcpsnd.isrequested {
|
||
@ function_return = 10000
|
||
if (ctcpsnd[$file.sanspath($*)] != []) @function_return = time() - ctcpsnd[$%file.sanspath($*)]
|
||
}
|
||
|
||
### returns 1 if we getting this file right now...
|
||
alias ctcpsnd.isgetting {
|
||
@ function_return = ctcpsnd.getting[$file.sanspath($*)] > 0
|
||
}
|
||
|
||
### usage is simple, in your own on ^dcc_request, do something like
|
||
### ^on dcc_request * if (!ctcpsnd.dcc_request($*)) {
|
||
### your code here
|
||
### }
|
||
|
||
alias ctcpsnd.dcc_request {
|
||
@ function_return = 0
|
||
if (ctcpsnd[$file.sanspath($2)] > 0) {
|
||
@function_return = 1
|
||
if (file.isdir($EXEDIR/SOUNDS)) {
|
||
@mkdir($EXEDIR/SOUNDS/RECV)
|
||
//^dcc rename $4 $EXEDIR/SOUNDS/RECV/$file.sanspath($2)
|
||
@ctcpsnd.getting[$file.sanspath($2)] = time()
|
||
^on ^dcc_connect "$4 $0 GET % %" #
|
||
//^dcc get $4
|
||
^on ^dcc_connect -"$4 $0 SEND % %"
|
||
if (dccitem($4) == []) {
|
||
//^assign -ctcpsnd.getting[$file.sanspath($2)]
|
||
//^assign -ctcpsnd[$file.sanspath($2)]
|
||
}{
|
||
//on ^dcc_lost "$4 $0 GET $word(8 $dccitem($4)) %*" {
|
||
@ctcpsnd.dcc_lost($*)
|
||
}
|
||
}
|
||
}{
|
||
//^assign -ctcpsnd.getting[$file.sanspath($2)]
|
||
//^assign -ctcpsnd[$file.sanspath($2)]
|
||
//^dcc close $4
|
||
}
|
||
}
|
||
}
|
||
|
||
### same here
|
||
|
||
alias ctcpsnd.dcc_lost {
|
||
@function_return = 0
|
||
if (ctcpsnd[$%file.sanspath($3)] > 0) {
|
||
@function_return = 1
|
||
switch ($4) {
|
||
(ERROR)(LOST)(CLOSED) {
|
||
@unlink($3)
|
||
//^assign -ctcpsnd.getting[$file.sanspath($3)]
|
||
//^assign -ctcpsnd[$file.sanspath($3)]
|
||
//hook ctcpsnd error $file.sanspath($3) closed
|
||
}
|
||
(COMPLETED) {
|
||
//^assign -ctcpsnd.getting[$file.sanspath($3)]
|
||
//^assign -ctcpsnd[$file.sanspath($3)]
|
||
if (fsize($3) && fsize($3) == word(7 $dccitem($0))) {
|
||
@rename($3 $exedir/sounds/$file.sanspath($3))
|
||
//^hook ctcpsnd received $exedir/sounds/$file.sanspath($3)
|
||
}{
|
||
if (fsize($3)) {
|
||
@unlink($3)
|
||
//hook ctcpsnd error file.sanspath($3) file size mistmatch
|
||
}{
|
||
@unlink($3)
|
||
//hook ctcpsnd error file.sanspath($3) zero length file
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//on ^dcc_lost -"$0 $1 $2 $3 %*"
|
||
}
|
||
}
|
||
|
||
### this function is called from main script /sound routine to find if
|
||
### we have a local file. If we do, it is assumed that we gonna send it,
|
||
### so its added to a circlular buffer of last 10 filenames sent via /sound
|
||
### if function returns 1, then ctcpsnd.fname will be a full filename, ready
|
||
### to be passed to mmpm.playfile
|
||
|
||
if (ctcpsnd.cansendidx == []) @ctcpsnd.cansendidx=0
|
||
|
||
alias ctcpsnd.localfile {
|
||
@ function_return = 1
|
||
# cannot send files which we are currently downloading yet
|
||
if (ctcpsnd.isgetting($*)) { @function_return = 0
|
||
} else if (file.exist($*)) {
|
||
@ ctcpsnd.fname = [$*]
|
||
@ ctcpsnd.cansend[$ctcpsnd.cansendidx] = [$*]
|
||
@ ctcpsnd.cansendidx = (ctcpsnd.cansendidx+1) % 10
|
||
} else if (file.exist(${ctcpsnd.fname = searchpath($* $SOUND_PATH)})) {
|
||
@ ctcpsnd.cansend[$ctcpsnd.cansendidx] = [$*]
|
||
@ ctcpsnd.cansendidx = (ctcpsnd.cansendidx+1) % 10
|
||
} else @function_return = 0
|
||
|
||
}
|
||
|
||
### $0 is what they requested, function returns 0 or 1, if it returns 1, then
|
||
### ctcpsnd.fname will be a file name for /dcc send
|
||
|
||
alias ctcpsnd.cansend {
|
||
@function_return = 0
|
||
if (rmatch($* %.wav %.au %.mid)) {
|
||
@ctcpsnd.tmp = file.sanspath($*)
|
||
foreach ctcpsnd.cansend ctcpsnd.ii {
|
||
if (ctcpsnd.tmp == file.sanspath($ctcpsnd.cansend[$ctcpsnd.ii])) {
|
||
if (file.exist($ctcpsnd.cansend[$ctcpsnd.ii])) {
|
||
@ ctcpsnd.fname = ctcpsnd.cansend[$ctcpsnd.ii]
|
||
@ function_return = 1
|
||
//break
|
||
} else if (file.exist(${ctcpsnd.fname = searchpath($file.sanspath($ctcpsnd.cansend[$ctcpsnd.ii]) $SOUND_PATH)})) {
|
||
@ function_return = 1
|
||
//break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
### next 3 ones should be called from ON ^PUBLIC, ON ^MSG and ^ON NOTICE
|
||
### Note that we only allow to request these sounds we just recently played
|
||
### using /sound, last 10 actually
|
||
|
||
alias ctcpsnd.msg {
|
||
@function_return = 0
|
||
if ([$1] == [!$N] && [$2] != [] && [$3] == []) {
|
||
@ function_return = 1
|
||
if (ctcpsnd.cansend($2)) {
|
||
//^hook ctcpsnd request 1 $0 $ctcpsnd.fname
|
||
ctcpsnd.sendfile_with_timeout $0 $ctcpsnd.fname
|
||
}{
|
||
//^hook ctcpsnd request 0 $0 $2
|
||
}
|
||
}
|
||
}
|
||
|
||
alias ctcpsnd.notice {
|
||
@function_return = 0
|
||
if (index(# $0) == -1 && ([$1] == [!dccsend] || [$1] == [!$N]) && [$2] != [] && [$3] == []) {
|
||
@ function_return = 1
|
||
if (ctcpsnd.cansend($2)) {
|
||
//^hook ctcpsnd request 1 $0 $ctcpsnd.fname
|
||
ctcpsnd.sendfile_with_timeout $0 $ctcpsnd.fname
|
||
}{
|
||
//^hook ctcpsnd request 0 $0 $2
|
||
}
|
||
}
|
||
}
|
||
|
||
alias ctcpsnd.public {
|
||
if ([$2] == [!$N] && ctcpsnd.cansend($3)) {
|
||
//^hook ctcpsnd request 1 $0 $ctcpsnd.fname
|
||
ctcpsnd.sendfile_with_timeout $0 $ctcpsnd.fname
|
||
}
|
||
}
|
||
|
||
|
||
alias ctcpsnd.close_unactive {
|
||
if (dccitem($0) != [] && word(2 $dccitem($0)) != [active]) {
|
||
//^dcc close $0
|
||
//^on ^dcc_connect -"$0 $1 SEND % %"
|
||
}
|
||
}
|
||
|
||
### $0 == nick, $1 == file
|
||
alias ctcpsnd.sendfile_with_timeout {
|
||
@ dnum = 0
|
||
on ^dcc_sent "$0 SEND % % #%" {@dnum = [$4]}
|
||
//^dcc send $0 $1-
|
||
on ^dcc_sent -"$0 SEND % % #%"
|
||
on ^dcc_connect "$dnum $0 SEND % %" {
|
||
//on ^dcc_connect -"$0 $1 SEND % %"
|
||
//on ^dcc_lost "$0 $1 SEND $word(8 $dccitem($0)) %*" {
|
||
//on ^dcc_lost -"$0 $1 $2 $3 %*"
|
||
}
|
||
}
|
||
if (dnum) /timer 180 ctcpsnd.close_unactive $dnum $0
|
||
}
|
||
|
||
alias file.exist {
|
||
@ function_return = fexist($*) == 1
|
||
}
|
||
|
||
alias file.isdir {
|
||
@ function_return = fexist($* d) == 1
|
||
}
|
||
|
||
alias file.sanspath {
|
||
if (file.spi=rindex(\\/: $*)+1) {
|
||
@function_return=mid($file.spi 255 $*)
|
||
} else {
|
||
@function_return=[$*]
|
||
}
|
||
}
|
||
|
||
alias file.ext {
|
||
@file.sp=file.sanspath($*)
|
||
if (file.exi=rindex(. $file.sp)+1) {
|
||
@function_return=[mid($file.exi 255 $file.sp)]
|
||
} else {
|
||
@ function_return = []
|
||
}
|
||
}
|
||
|
||
alias file.sansext {
|
||
@file.sp=file.sanspath($*)
|
||
if (file.sei=rindex(. $file.sp)+1) {
|
||
@function_return=left(${[$@*] - ((@file.sp - file.sei) + 1)} $*)
|
||
} else {
|
||
@function_return=[$*]
|
||
}
|
||
}
|
||
|
||
alias file.path {
|
||
if (file.spi=rindex(\\/: $*)+1) {
|
||
@function_return=[mid(0 $file.spi $*)]
|
||
} else {
|
||
@function_return=[]
|
||
}
|
||
}
|
||
|
||
alias file.tofat {
|
||
@file.path=file.path($*)
|
||
@file.name=file.sansext($file.sanspath($*))
|
||
@file.ext=file.ext($*)
|
||
# if extention is >3 chars long truncate it
|
||
if (@file.ext > 3) @file.ext=left(3 $file.ext)
|
||
if (@file.name > 8) {
|
||
@file.tohash=right(${@file.name-5} $file.name)
|
||
echo +++ tohash = $file.tohash
|
||
@file.name=left(5 $file.name)
|
||
@file.tmp=0
|
||
fec ($file.tohash) file.c {
|
||
@file.tmp = file.tmp + ascii($toupper($file.c))
|
||
}
|
||
echo +++ result = $file.tmp
|
||
@file.tmp = file.tmp % 256
|
||
@file.name #= file.tmp
|
||
}
|
||
if (file.path) @function_return=[$file.path/$file.name\.$file.ext] else @function_return=[$file.name\.$file.ext]
|
||
}
|
||
|
||
alias mmpm.debug {
|
||
if (mmpm.debug) {xecho +++ [mmpm] $*}
|
||
}
|
||
|
||
if (!mmpm.loaded) {
|
||
@ mmpm.loading = 1
|
||
@ mmpm.multimedia = mciapi()
|
||
if (!mmpm.multimedia) { /mmpm.debug
|
||
} else { /mmpm.debug }
|
||
@ mmpm.loaded = 1
|
||
@ mmpm.volume = mmpm.midi.volume = mmpm.wave.volume = 100
|
||
}
|
||
### outside of 1st if in case we loading it over an older mmpm.api version...
|
||
if (mmpm.wave.state == [] && mmpm.midi.state == []) {
|
||
@ mmpm.wave.state = [CLOSED]
|
||
@ mmpm.midi.state = [CLOSED]
|
||
}
|
||
|
||
### always interrups previous sound
|
||
|
||
#alias mmpm.playfile {
|
||
# @mmpm.donotstop = 0
|
||
# mmpm.playfile_internal $*
|
||
#}
|
||
|
||
#alias mmpm.playfile2 {
|
||
# @mmpm.donotstop = [$0]
|
||
# mmpm.playfile_internal $1-
|
||
#}
|
||
|
||
#I am not sure why the raw version of mmpm.playfile does not work...
|
||
#until I figure it out...
|
||
|
||
alias mmpm.playfile {
|
||
eval $mciapi(playfile $0)
|
||
}
|
||
|
||
alias mmpm.playfile2 {
|
||
eval $mciapi(playfile $0)
|
||
}
|
||
|
||
|
||
alias mmpm.sendplaycmd {
|
||
@ mmpm[$device][nextfile] = [$*]
|
||
switch ($mmpm[$device][state]) {
|
||
(CLOSED) {
|
||
if (device == [wave]) { @ device.name = [waveaudio]
|
||
} else if (device == [midi]) { @ device.name = [sequencer]
|
||
} else { @ device.name = 0 }
|
||
mmpm.raw open $device.name alias $device$pid() shareable
|
||
if (!mmpm.err) @mmpm[$device][state] = [OPEN_WAIT]
|
||
}
|
||
(PLAYING) {
|
||
### let the stop notification kick in next file
|
||
mmpm.raw stop $device$pid()
|
||
if (mmpm.err) {mmpm.close}
|
||
}
|
||
}
|
||
}
|
||
|
||
### should return a device name 'wave' or 'midi' for a filename passed
|
||
### as a parameter
|
||
alias mmpm.get_device_for_file {
|
||
@ function_return = 0
|
||
switch ($*) {
|
||
(*.wav)(*.au)("*.wav")("*.au") {
|
||
@ function_return = [wave]
|
||
}
|
||
(*.mid)(*.midi)("*.mid")("*.midi") {
|
||
@ function_return = [midi]
|
||
}
|
||
(*) {
|
||
### todo: default, may open file and look for a header
|
||
}
|
||
}
|
||
}
|
||
|
||
alias mmpm.playfile_internal {
|
||
if (mmpm.multimedia && file.exist($*)) {
|
||
@ device = mmpm.get_device_for_file($*)
|
||
if (device) {
|
||
if (!mmpm.donotstop || mmpm[$device][state] != [PLAYING])
|
||
{
|
||
mmpm.sendplaycmd $*
|
||
}
|
||
}{
|
||
mmpm.debug +++ Unknown file extention `$*'
|
||
}
|
||
}
|
||
}
|
||
|
||
# Numeric code for commands we use:
|
||
#
|
||
|
||
@mmpm.commands[OPEN] = 1
|
||
@mmpm.commands[CLOSE] = 2
|
||
@mmpm.commands[LOAD] = 22
|
||
@mmpm.commands[PLAY] = 4
|
||
@mmpm.commands[STOP] = 6
|
||
|
||
#
|
||
# These are notification codes, anything else is an error code and
|
||
# error description can be found using mciapi(errorstr code) function
|
||
#
|
||
# #define MCI_NOTIFY_SUCCESSFUL 0x0000
|
||
# #define MCI_NOTIFY_SUPERSEDED 0x0001
|
||
# #define MCI_NOTIFY_ABORTED 0x0002
|
||
# #define MCI_NOTIFY_ERROR 0x0003
|
||
|
||
### global variable device == wave or midi
|
||
|
||
alias mmpm.close {
|
||
if (mmpm[$device][state] != [CLOSED] && mmpm[$device][state] != [CLOSE_WAIT]) {
|
||
mmpm.raw close $device$pid()
|
||
if (!mmpm.err) { @ mmpm[$device][state] = [CLOSE_WAIT]
|
||
} else { @ mmpm[$device][state] = [CLOSED] }
|
||
}
|
||
}
|
||
|
||
### #define MCIERR_BASE 5000
|
||
|
||
alias mmpm.raw {
|
||
mmpm.debug Raw $*
|
||
@mmpm.result = mciapi(raw ${device==[wave]?11:12} $* notify)
|
||
@mmpm.err = mmpm.result > 5000
|
||
}
|
||
|
||
alias mmpm.kickload {
|
||
if (mmpm[$device][nextfile] != []) {
|
||
mmpm.raw load $device$pid() $mmpm[$device][nextfile] ${device==[wave]?[readonly]:[]}
|
||
if (!mmpm.err) {
|
||
@mmpm[$device][state] = [LOAD_WAIT]
|
||
@mmpm[$device][nextfile] = []
|
||
}{
|
||
mmpm.close
|
||
}
|
||
}{
|
||
mmpm.close
|
||
}
|
||
}
|
||
|
||
|
||
### we are receiving control of a device
|
||
on ^mci_notify "passdevice % 2" {
|
||
if ([$1] == mmpm.wave) { @ device = [wave]
|
||
} else if ([$1] == mmpm.midi) { @ device = [midi]
|
||
} else { @ device = 0 }
|
||
if (device) {
|
||
if (mmpm[$device][state] == [OPENED]) {
|
||
mmpm.kickload
|
||
}
|
||
} else {
|
||
mmpm.debug +++ Aqured device $1 (not opened by mmpm.api module)
|
||
}
|
||
}
|
||
|
||
### we are loosing control of a device, so lets close it to avoid confusion
|
||
on ^mci_notify "passdevice % 1" {
|
||
if ([$1] == mmpm.wave) { @ device = [wave]
|
||
} else if ([$1] == mmpm.midi) { @ device = [midi]
|
||
} else @ device = 0
|
||
if (device) {
|
||
mmpm.debug someone is taking device from us...
|
||
mmpm.close
|
||
}
|
||
}
|
||
|
||
### This is a main handler of notifications from mmpm/2, each command we
|
||
### issue (except set volume ones) have `nofify' flag, and is confirmed here.
|
||
### Much to my surprise I yet have to see mmpm/2 to lose notifications...
|
||
|
||
on ^mci_notify "NOTIFY % 1? % %" {
|
||
mmpm.debug Notify $*
|
||
if ([$2] == 11) { @ device = [wave]
|
||
} else if ([$2] == 12) { @ device = [midi]
|
||
} else @ device = 0
|
||
if (device)
|
||
{
|
||
if ([$4] == mmpm.commands[OPEN]) {
|
||
### open notification
|
||
if ([$1] == 0) {
|
||
@ mmpm[$device] = [$3]
|
||
@ mmpm[$device][state] = [OPENED]
|
||
### it waits for passdevice now, which gonna start file loading
|
||
}{
|
||
mmpm.close
|
||
}
|
||
} else if ([$4] == mmpm.commands[LOAD]) {
|
||
### load notification, lets play it now when it finished loading
|
||
if ([$1] == 0) {
|
||
if (mmpm[$device][volume] != 100) {
|
||
if (device == [midi]) { @mciapi(raw set midi$pid() volume $mmpm[$device][volume])
|
||
} else if (device == [wave]) { @mciapi(raw set wave$pid() audio volume all $mmpm[$device][volume]) }
|
||
}
|
||
mmpm.raw play $device$pid()
|
||
if (!mmpm.err) { @ mmpm[$device][state] = [PLAYING]
|
||
} else {
|
||
mmpm.close
|
||
}
|
||
}{
|
||
mmpm.close
|
||
}
|
||
} else if ([$4] == mmpm.commands[PLAY]) {
|
||
### play is finished, try to start next file in case we were stopped
|
||
mmpm.kickload
|
||
} else if ([$4] == mmpm.commands[STOP]) {
|
||
### stop notification, not actually used anyhow
|
||
mmpm.debug Stop confirmed
|
||
} else if ([$4] == mmpm.commands[CLOSE]) {
|
||
### close notification, lets mark device as closed...
|
||
if ([$1] == 0) {
|
||
@mmpm[$device][state] = [CLOSED]
|
||
@mmpm[$device] = 0
|
||
}
|
||
}
|
||
} else {
|
||
mmpm.debug +++ Unknown device $3 notification received
|
||
}
|
||
}
|
||
|
||
alias mmpm.midi.stop {
|
||
@ device=[midi]
|
||
mmpm.close
|
||
}
|
||
|
||
alias mmpm.wave.stop {
|
||
@ device=[wave]
|
||
mmpm.close
|
||
}
|
||
|
||
alias mmpm.stop {
|
||
mmpm.wave.stop
|
||
mmpm.midi.stop
|
||
}
|
||
|
||
alias mmpm.midi.volume {
|
||
@ mmpm.midi.volume = [$0]
|
||
if (mmpm.midi.state == [PLAYING]) @mciapi(raw set midi$pid() volume $0)
|
||
}
|
||
|
||
|
||
alias mmpm.wave.volume {
|
||
@ mmpm.wave.volume = [$0]
|
||
if (mmpm.wave.state == [PLAYING]) @mciapi(raw set wave$pid() audio volume all $0)
|
||
}
|
||
|
||
alias mmpm.volume {
|
||
mmpm.wave.volume $0
|
||
mmpm.midi.volume $0
|
||
}
|
||
|
||
### these are aliases for debugging, /mci <mci string commands> sends a raw
|
||
### command to mmpm/2 and displays result and an error string in case of error
|
||
|
||
/on ^mci_notify * {echo [mci] $*}
|
||
|
||
/alias mci {
|
||
@ _rc = mciapi(raw $0-)
|
||
if (_rc) {
|
||
echo [mci] Error: $mciapi(errstring $_rc)
|
||
}{
|
||
if (mciapi(result) != []) {
|
||
echo [mci] Result: $mciapi(result)
|
||
}
|
||
}
|
||
}
|
||
#############
|
||
#GemZ Extras#
|
||
#############
|
||
@ gz.extras = 1
|
||
|
||
#########################################################################
|
||
### figlet v1.0 support by Kanji_Man. Modified by Gemini
|
||
### Modified by OS2-Mike
|
||
# fixed code by OS2-Mike (with a lot of help from mikh)
|
||
# fixored the prob of 4OS2 echoing its logo info into the figlet pipe.
|
||
# filget.exe is borked - it expects a ^Z EOF to terminate it -
|
||
# added to $fig.text
|
||
# Modified slightly by gemini to replace ^Z with $chr(26) :)
|
||
#########################################################################
|
||
@ def.figfont = [short]
|
||
@ fig.fontdir = [$exedir/fonts]
|
||
@ figfont = [$fig.fontdir/bubble.flf]
|
||
alias figfix {
|
||
if ([$0]) {
|
||
@ figfix.count = 0
|
||
^assign -figfix.text
|
||
while ([$@0-]>=[$figfix.count]) {
|
||
@ figfix.char = [$mid($figfix.count 1 $0-)]
|
||
if ([$strip(<>\;\(\)*/\\\{\}$$~`|'\" $figfix.char)]!=[$figfix.char]) {
|
||
@ figfix.text = [$figfix.text\\]
|
||
}
|
||
if (figfix.char) {
|
||
^assign figfix.text $figfix.text$figfix.char
|
||
} else {^assign figfix.text $figfix.text}
|
||
@ figfix.count++
|
||
}
|
||
@ FUNCTION_RETURN = [$encode($figfix.text)]
|
||
purge fixfix
|
||
} else {gecho [Error] FIGFIX is an internal alias, avoid using!}
|
||
}
|
||
|
||
alias fig figlet $*
|
||
#alias figlist {^exec -name figlet ls $fig.fontdir/*.flf}
|
||
alias figlist {
|
||
gecho Starting Font list
|
||
fe ($findfiles(fn $fig.fontdir/*.flf)) _f.1 _f.2 _f.3 _f.4 {
|
||
gecho $[15]_f.1 $[15]_f.2 $[15]_f.3 $[15]_f.4
|
||
}
|
||
gecho End of Font list
|
||
purge _f
|
||
}
|
||
|
||
alias figlet {
|
||
if ([$0]) {
|
||
@ fig.text = encode($strip(| $1-)) ## encode($chr(26))
|
||
^on ^exec_error "figlet *" {gecho [ERROR] Cannot load figlet!}
|
||
if ([$0]==[*]) {^exec -name figlet -out figlet -f $figfont;^msg %figlet $decode($fig.text)
|
||
} else {^exec -name figlet -msg $0 figlet -f $figfont;^msg %figlet $decode($fig.text)}
|
||
^assign -fig.text
|
||
} else {gecho Usage: /FIGLET <nick/channel> <text>}
|
||
}
|
||
|
||
alias figfont {
|
||
if ([$0]) {
|
||
@ figfont.file = [$0]
|
||
if ([$fexist($fig.fontdir/$figfont.file\.flf)]==[1]) {
|
||
gecho Figlet font changed from $fig.fontfile\ to $figfont.file\.
|
||
@ figfont = [$fig.fontdir/$figfont.file\.flf]
|
||
@ fig.fontfile = [$figfont.file]
|
||
if ([$1]==[-d]) {@ def.figfont = [$figfont.file];gecho Default Figlet Font Changed}
|
||
^assign -figfont.file
|
||
} else {gecho [Error] Figlet font not found: $figfont.file\}
|
||
} else {
|
||
gecho Current Figlet Font: $fig.fontfile\
|
||
gecho Usage: /FIGFONT <fontfile>
|
||
}
|
||
}
|
||
|
||
alias figdir {
|
||
input "Please Enter The directory where you fonts are located: " if ([$0]) {
|
||
if ([$fexist($0-)]==[1]) {
|
||
@ fig.fontdir = [$0-]
|
||
gecho Figlet Font Directory Changed to $fig.fontdir
|
||
}
|
||
} else {
|
||
gecho Figlet Font Directory is $fig.fontdir
|
||
}
|
||
figfont $fig.fontfile
|
||
}
|
||
|
||
#added by request -- Ripped from Kanji :)
|
||
alias bleah {
|
||
if ([$0]) {
|
||
^msg $0 \\|/ ____ \\|/ \\|/ ____ \\|/
|
||
^msg $0 ~ @ -/ oO \\- @ ~ ~ @ -/ Oo \\- @ ~
|
||
^msg $0 /_\( \\__/ \)_\\ Bleah!! /_\( \\__/ \)_\\;
|
||
^msg $0 \\__U_/ \\_U__/
|
||
gecho BLEAH launched on $0.
|
||
}{gecho Usage: /BLEAH <nick/channel>}
|
||
}
|
||
alias bork {
|
||
if (C) {
|
||
@ _o.s = lastserver()
|
||
@ _o.t = _dfn($_o.s)
|
||
evalserver $_o.s @ _o.n = N
|
||
evalserver $_o.s @ _o.c = C
|
||
evalserver $_o.s nick SwdshChef
|
||
evalserver $_o.s WAIT
|
||
evalserver $_o.s saysend $_o.c bork bork bork bork
|
||
evalserver $_o.s nick $_o.n
|
||
@ _rfn($_o.s $_o.t)
|
||
purge _o
|
||
}{gecho Yer not on a channel in this window.}
|
||
}
|
||
|
||
alias _dfn {
|
||
@ function_return = fn[$servergroup($0)]
|
||
@ fn[$servergroup($0)] = 0
|
||
}
|
||
alias _rfn {@ fn[$servergroup($0)] = [$1]}
|
||
|
||
alias fozzie {
|
||
if (C) {
|
||
@ _o.s = lastserver()
|
||
@ _o.t = _dfn($_o.s)
|
||
evalserver $_o.s @ _o.c = C
|
||
evalserver $_o.s @ _o.n = N
|
||
evalserver $_o.s nick _fozzie_
|
||
evalserver $_o.s WAIT
|
||
evalserver $_o.s saysend $_o.c wakka wakka wakka
|
||
evalserver $_o.s nick $_o.n
|
||
@ _rfn($_o.s $_o.t)
|
||
purge _o
|
||
}{gecho Your not in a channel in this window.}
|
||
}
|
||
|
||
alias beaker {@ o.n = [$N];nick _Beaker_;WAIT;say meep meep meep meep;nick $o.n;^assign -o.n}
|
||
|
||
alias gimpkick {
|
||
@ _g.s = lastserver()
|
||
@ _g.t = _dfn($_g.s)
|
||
@ _g.n = N
|
||
@ _g.c = C
|
||
if (ischanop($_g.n $_g.c)) {
|
||
evalserver $_g.s saysend $_g.c $0, I think The Gimp would love a piece of meat like you...
|
||
evalserver $_g.s saysend $_g.c You're the kind of piece of shit trash he likes...
|
||
evalserver $_g.s nick _The_Gimp_
|
||
evalserver $_g.s WAIT
|
||
evalserver $_g.s saysend $_g.c ARRRGGGGGGGGGHHHHHHHH!!!!!
|
||
evalserver $_g.s saysend $_g.c I'm gonna drill you a new asshole!!!
|
||
evalserver $_g.s WAIT
|
||
evalserver $_g.s me Bends $0 over and "goes to town" on him!
|
||
evalserver $_g.s saysend $_g.c AAHHHHHHHHHHHHHHHHHHHHHHHHHHH!!!!
|
||
evalserver $_g.s saysend $_g.c Feels so fuckin good don't it boy!!!!?????
|
||
evalserver $_g.s WAIT
|
||
evalserver $_g.s me zip up $gender leather pants and leaves $0 crying and rubbing his ass!
|
||
evalserver $_g.s //kick $_g.c $0 You're good...you should give references...
|
||
evalserver $_g.s nick $_g.n
|
||
@ _rfn($_g.s $_g.t)
|
||
}{gecho You're not a channel Operator}
|
||
purge _g
|
||
}
|
||
#
|
||
alias soupkick {
|
||
@ _s.s = lastserver()
|
||
@ _s.t = _dfn($_s.s)
|
||
@ _s.c = C
|
||
if (ischanop($N $C)) {
|
||
evalserver $_s.s @ _s.n = N
|
||
evalserver $_s.s nick Soup_Nzi
|
||
evalserver $_s.s Wait
|
||
evalserver $_s.s saysend $_s.c VAT!??!??!!!!
|
||
evalserver $_s.s //kick $_s.c $0 N() S()UP F()R Y()U
|
||
evalserver $_s.s Wait
|
||
evalserver $_s.s nick $_s.n
|
||
@ _rfn($_s.s $_s.t)
|
||
}
|
||
purge _s
|
||
}
|
||
|
||
#ripped from Kanji_man
|
||
alias gerbilkick {
|
||
if (ischanop($N $C)) {
|
||
@ old_nick = N
|
||
say $0, watch out for the giant gerbil...
|
||
say I hear he likes MomoBoys like you...
|
||
nick _Gerbil_
|
||
WAIT
|
||
me towers above the entire channel... looking for pleasure...
|
||
me reaches down and grabs $0 by the shoulders with one claw...
|
||
WAIT
|
||
me bends over, parts both cheeks with the other claw...
|
||
WAIT
|
||
me begins to scream as a muffled shreek can be heard from $0
|
||
/k $0 SCREEEEEEEEEEEEEECH!
|
||
nick $old_nick
|
||
^assign -old_nick
|
||
}{gecho You're not a channel operator}
|
||
}
|
||
###Pimp Ideas Ripped from PimpToolz
|
||
alias pimpslap {
|
||
if (ischanop($N $C)) {
|
||
@ old_nick = N
|
||
nick PimpGuido
|
||
WAIT
|
||
say WhaT HaPPenS wHeN YeR hO dOn'T WoRk? ?
|
||
/k $0 !PiMPSlaP HeR!
|
||
WAIT
|
||
nick $old_nick
|
||
WAIT
|
||
^assign -old_nick
|
||
}{gecho You're not a channel operator}
|
||
}
|
||
alias pimpkick {
|
||
if (ischanop($N $C)) {
|
||
@ old_nick = N
|
||
nick PimpGuido
|
||
WAIT
|
||
say WHAT IS THE MEANING OF PIMP?
|
||
say PiMP = PoWeR!
|
||
say PiMP = PoWeR!
|
||
say PiMP = PoWeR!
|
||
WAIT
|
||
/k $0 !PiMP-PoWeR! !PiMP-PoWeR!
|
||
WAIT
|
||
nick $old_nick
|
||
WAIT
|
||
^assign -old_nick
|
||
}{gecho You're not a channel Operator}
|
||
}
|
||
alias stinkkick {
|
||
if (ischanop($N $C)) {
|
||
say ShiT SomEThinG FuXin G StINkS !!!
|
||
/k $0 !ThaT'S BeTTeR!
|
||
}{gecho You're not a channel Operator}
|
||
}
|
||
alias lamahkick {
|
||
if (ischanop($N $C)) {
|
||
say I'M A LaMaH HawK...
|
||
say HuNtInG FoR A LaMaH ...
|
||
/k $0 !FuXinG LaMaH!
|
||
}{gecho You're not a channel Operator}
|
||
}
|
||
|
||
#-------------------------------------------------------------------------#
|
||
#Swedish Chef Filter by gemini
|
||
alias chefsay {
|
||
@ in_line = [$0-]
|
||
fe ($in_line) _in_word {
|
||
switch ($_in_word) {
|
||
(bork) {@ _out_line = _out_line ## [$_in_word]}
|
||
(*tion) {
|
||
@ _len = [$@_in_word] - 4
|
||
@ _out_line = [$_out_line ]##[$subchef($left($_len $_in_word))]##[shun]
|
||
}
|
||
(an) {@ _out_line = _out_line ## [un ]}
|
||
(the) {@ _out_line = _out_line ## [zee ]}
|
||
(*) {@ _out_line = _out_line##[$subchef($_in_word)]
|
||
}
|
||
}
|
||
}
|
||
say $_out_line
|
||
^assign -_out_line;^assign -_in_line;^assign -_in_word
|
||
}
|
||
|
||
alias chefme {
|
||
@ in_line = [$0-]
|
||
fe ($in_line) _in_word {
|
||
switch ($_in_word) {
|
||
(bork) {@ _out_line = _out_line ## [$_in_word]}
|
||
(*tion) {
|
||
@ _len = [$@_in_word] - 4
|
||
@ _out_line = [$_out_line ]##[$subchef($left($_len $_in_word))]##[shun]
|
||
}
|
||
(an) {@ _out_line = _out_line ## [un]}
|
||
(the) {@ _out_line = _out_line ## [zee]}
|
||
(*) {@ _out_line = _out_line##[$subchef($_in_word)]
|
||
}
|
||
}
|
||
}
|
||
me $_out_line
|
||
^assign -_out_line;^assign -_in_line;^assign -_in_word
|
||
}
|
||
|
||
alias chefmsg {
|
||
@ in_line = [$1-]
|
||
fe ($in_line) _in_word {
|
||
switch ($_in_word) {
|
||
(bork) {@ _out_line = _out_line ## [$_in_word]}
|
||
(*tion) {
|
||
@ _len = [$@_in_word] - 4
|
||
@ _out_line = [$_out_line ]##[$subchef($left($_len $_in_word))]##[shun]
|
||
}
|
||
(an) {@ _out_line = _out_line ## [un]}
|
||
(the) {@ _out_line = _out_line ## [zee]}
|
||
(*) {@ _out_line = _out_line ##[$subchef($_in_word)]
|
||
}
|
||
}
|
||
}
|
||
/msg $0 $_out_line
|
||
^assign -_out_line;^assign -_in_line;^assign _in_word
|
||
}
|
||
|
||
alias subchef {
|
||
@ __bork = [$0]
|
||
fec ($__bork) _bork {
|
||
switch ($_bork) {
|
||
(a) {@ bork_return = bork_return ## [e]}
|
||
(e) {@ bork_return = bork_return ## [i]}
|
||
(f) {@ bork_return = bork_return ## [ff]}
|
||
(i) {@ bork_return = bork_return ## [ee]}
|
||
(v) {@ bork_return = bork_return ## [f]}
|
||
(o) {@ bork_return = bork_return ## [u]}
|
||
(u) {@ bork_return = bork_return ## [oo]}
|
||
(w) {@ bork_return = bork_return ## [v]}
|
||
#(.) {@ bork_return = bork_return ## [. Bork Bork Bork!]}
|
||
(!) {@ bork_return = bork_return ## [! Bork Bork Bork!]}
|
||
(*) {@ bork_return = bork_return ## [$_bork]}
|
||
}
|
||
}
|
||
@ FUNCTION_RETURN = [$bork_return ]
|
||
^assign -bork_return;^assign -_bork;^assign -__bork
|
||
}
|
||
|
||
alias postal {
|
||
if (C) {
|
||
@ _p.s = lastserver()
|
||
@ _p.t = _dfn($_p.s)
|
||
@ _p.c = C
|
||
@ _p.mn = N
|
||
evalserver $_p.s if (ischanop($_p.mn $_p.c)) {
|
||
if ([$0]==[all]) {
|
||
evalserver $_p.s @ _p.l = chanusers($_p.c)
|
||
}{
|
||
evalserver $_p.s fe ($chanusers($_p.c)) _p.u {if (!ischanop($_p.u $_p.c)) {@ _p.l = [$_p.l $_p.u]}}
|
||
}
|
||
@ _p.n = [$mid(0 3 $_p.mn)]
|
||
@ _p.n = [$_p.n]##[Postal]
|
||
@ _p.o = [$_p.mn]
|
||
evalserver $_p.s /me suddenly has an urge to become a postal worker.
|
||
evalserver $_p.s /nick $_p.n
|
||
evalserver $_p.s WAIT
|
||
evalserver $_p.s /me grabs an assault weapon and picks a random person...
|
||
evalserver $_p.s //kick $_p.c $word($rand($#_p.l - 1) $_p.l) pOsTaLkIcK vIcTiM
|
||
evalserver $_p.s /nick $_p.o
|
||
@ _rfn($_p.s $_p.t)
|
||
}{gecho You don't own a gun, You can't go postal without one!}
|
||
}{gecho Not in a channel, how can you go postal???}
|
||
purge _p
|
||
}
|
||
|
||
alias gz.unloadextras {
|
||
^alias -bleah;^alias -bork;^alias -fozzie;^alias -beaker
|
||
^alias -postal;^alias -chefme;^alias -chefsay;^alias -subchef
|
||
^alias -gimpkick;^alias -soupkick;^alias -gerbilkick;^alias -pimpslap
|
||
^alias -pimpkick;^alias -pimpslap;^alias -lamahkick;^alias -stinkkick
|
||
^assign -gz.extras;
|
||
^timer 1 ^alias -gz.unloadextras
|
||
^timer 2 makegemzmenu
|
||
}
|
||
|
||
#Stripw (orginal asmodean)
|
||
alias stripw {
|
||
for (@ __i = 1, [$($__i)] != [], @ __i = __i + 1) {
|
||
if ([$($__i)] != [$0]) {@ _sw = _sw ## [ $($__i)]}
|
||
}
|
||
@ function_return = mid(1 2048 $_sw)
|
||
^assign -_sw;
|
||
}
|
||
|
||
alias _srvc.menu {
|
||
if (isconnected($0)) {
|
||
# //window goto ${ww = _srv.win($0)}
|
||
//xecho -window $ww $SHOW_NUMERICS_STR\This server is connected or in process of connecting
|
||
} else {
|
||
//server $0
|
||
}
|
||
}
|
||
|
||
alias _srvn.menu {
|
||
if (isconnected($0)) {
|
||
# //window goto ${ww = _srv.win($0)}
|
||
//xecho -window $ww $SHOW_NUMERICS_STR\This server is connected or in process of connecting
|
||
} else {
|
||
//window create server $0
|
||
}
|
||
}
|
||
|
||
alias _cm {if ([$0]==[ON] || [$0]==[YES] || [$0]==[1]) {@ FUNCTION_RETURN = [-c]}
|
||
}
|
||
|
||
alias makemenu {
|
||
^menu -menubar
|
||
^menu menubar
|
||
|
||
^submenu menubar main -s "~Main"
|
||
^submenu menubar join -s "~Join"
|
||
^submenu menubar user -s "~User"
|
||
^submenu menubar server -s "~Server"
|
||
^submenu menubar cdcc -s "~CDCC"
|
||
^submenu menubar msgs -s "M~esgs"
|
||
^submenu menubar bx -s "~BitchX"
|
||
#^submenu menubar window -s "~Windows"
|
||
^submenu menubar help -s "~Help"
|
||
|
||
^makemain
|
||
^makejoin
|
||
^makeuser
|
||
^makeserver
|
||
^makecdcc
|
||
^makemesgs
|
||
^makebx
|
||
#^makewindows
|
||
^makehelp
|
||
|
||
^set DEFAULT_MENU menubar
|
||
|
||
^window menu menubar
|
||
}
|
||
|
||
alias makemain {
|
||
menu -main
|
||
menu main
|
||
^submenu main saveset "Save Settings"
|
||
^menuitem saveset "Save All" {
|
||
/save
|
||
/cdcc save
|
||
}
|
||
^menuitem saveset "Save BitchX Settings" {/save}
|
||
^menuitem saveset "Save CDCC pack list" {/cdcc save}
|
||
^submenu main clrscr "Clear Screen"
|
||
^menuitem clrscr "Clear Screen" {/clear}
|
||
^menuitem clrscr "Clear All" {/clear -all}
|
||
^menuitem clrscr "Clear Scrollback" {/clear -scrollback}
|
||
^menuitem clrscr "Clear All Scrollback" {/clear -scrollback -all}
|
||
^submenu main settings "Settings"
|
||
^menuitem settings -n -c $_cm($ctcpsound) 9 "Ctcp Sound" {
|
||
if (ctcpsound == [ON]) {
|
||
@ ctcpsound = [OFF]
|
||
@ menucontrol(settings 9 check 0)
|
||
} else {
|
||
@ ctcpsound = [ON]
|
||
@ menucontrol(settings 9 check 1)
|
||
}
|
||
}
|
||
^menuitem settings -n -c $_cm($ctcpsndreq) 10 "Ctcp Sound Request" {
|
||
if (ctcpsndreq == [ON]) {
|
||
@ ctcpsndreq = [OFF]
|
||
@ menucontrol(settings 10 check 0)
|
||
} else {
|
||
@ ctcpsndreq = [ON]
|
||
@ menucontrol(settings 10 check 1)
|
||
}
|
||
}
|
||
^menuitem settings -n -c $_cm($loadacts) 11 "Load Action File" {
|
||
if (loadacts == [YES]) {
|
||
@ loadacts = [NO]
|
||
@ menucontrol(settings 11 check 0)
|
||
} else {
|
||
@ loadacts = [YES]
|
||
@ menucontrol(settings 11 check 1)
|
||
}
|
||
}
|
||
|
||
if (ctcpsound == [ON]) {
|
||
@ menucontrol(settings 9 check 1)
|
||
} else {
|
||
@ menucontrol(settings 9 check 0)
|
||
}
|
||
if (ctcpsndreq == [ON]) {
|
||
@ menucontrol(settings 10 check 1)
|
||
} else {
|
||
@ menucontrol(settings 10 check 0)
|
||
}
|
||
if (loadacts == [YES]) {
|
||
@ menucontrol(settings 11 check 1)
|
||
} else {
|
||
@ menucontrol(settings 11 check 0)
|
||
}
|
||
|
||
^menuitem main "Properties" {/properties}
|
||
^menuitem main "Change Font" {/fontdialog 0 0}
|
||
^menuitem main separator
|
||
^menuitem main "Quit" {/quit}
|
||
}
|
||
|
||
alias makejoin {
|
||
menu -join
|
||
menu join
|
||
for (@ ajl=0, ajoinitem($ajl), @ajl++) {
|
||
@ ajlchan = [$word(0 $ajoinitem($ajl))]
|
||
@ ajlkey = [$word(1 $ajoinitem($ajl))]
|
||
submenu join join$ajl "$ajlchan"
|
||
menuitem join$ajl -d "Join Channel" {j $ajlchan $ajlkey}
|
||
menuitem join$ajl "Leave Channel" {leave $ajlchan}
|
||
menuitem join$ajl "Cycle Channel" {cycle $ajlchan}
|
||
menuitem join$ajl "Remove From List" {unajoin $ajlchan}
|
||
}
|
||
menuitem join separator
|
||
menuitem join "Leave ~Current Channel" {l}
|
||
menuitem join "~Leave & Kill Current Window" {window delete}
|
||
menuitem join "~Show AutoJoinList" {ajoinlist}
|
||
# gz.addonjoin
|
||
# menu join -reset
|
||
}
|
||
|
||
alias makeuser {
|
||
menu -user
|
||
menu user
|
||
^menuitem user "Set Away" {/away $J Away}
|
||
^menuitem user "Set Back" {/back}
|
||
^menuitem user separator
|
||
^menuitem user "Show Notify" {//notify}
|
||
}
|
||
|
||
alias makeserver {
|
||
menu -srv
|
||
menu srv
|
||
submenu server srvc "Change Current Server"
|
||
submenu server srvn "Connect to new server"
|
||
purge srvgrp
|
||
for (@ srv=0, servername($srv), @srv++) {
|
||
if (srvgrp = servergroup($srv)) {
|
||
if (!srvgrp[srvc][$encode($srvgrp)]) {
|
||
@ srvgrp[srvc][$encode($srvgrp)] = 1
|
||
submenu srvc srvc_$encode($srvgrp) "$srvgrp"
|
||
}
|
||
menuitem srvc_$encode($srvgrp) "$servername($srv):$word(0 $serverport($srv))" {_srvc.menu $srv}
|
||
# if submenu does not exist
|
||
if (!srvgrp[srvn][$encode($srvgrp)]) {
|
||
@ srvgrp[srvn][$encode($srvgrp)] = 1
|
||
submenu srvn srvn_$encode($srvgrp) "$srvgrp"
|
||
}
|
||
menuitem srvn_$encode($srvgrp) "$servername($srv):$word(0 $serverport($srv))" {_srvn.menu $srv}
|
||
} else {
|
||
#servers without a group
|
||
menuitem srvc "$servername($srv):$word($serverport($srv))" {_srvc.menu $srv}
|
||
menuitem srvn "$servername($srv):$word($serverport($srv))" {_srvn.menu $srv}
|
||
# menuitem srvc ${isconnected($srv)?[-c]:[]} "$servername($srv):$word($serverport($srv))" {_srvc.menu $srv}
|
||
# menuitem srvn ${isconnected($srv)?[-c]:[]} "$servername($srv):$word($serverport($srv))" {_srvn.menu $srv}
|
||
}
|
||
}
|
||
menuitem srvc separator
|
||
menuitem srvc "Manually enter server: " { manserv }
|
||
menuitem srvn separator
|
||
menuitem srvn "Manually enter server: " { manservn }
|
||
menuitem server separator
|
||
^menuitem server "Reconnect" {/rec}
|
||
^menuitem server "Disconnect" {/disco}
|
||
^menuitem server separator
|
||
^submenu server servinfo "Server Information"
|
||
^menuitem servinfo "Administration" {/admin}
|
||
^menuitem servinfo "List users" {/luser}
|
||
^menuitem servinfo "Message of the Day" {/motd}
|
||
^menuitem servinfo "Server Links" {/links}
|
||
^menuitem servinfo "Server Uptime" {/stats u}
|
||
^submenu server ov "Toggle OperView"
|
||
^menuitem ov "On" {/ov on}
|
||
^menuitem ov "Off" {/ov off}
|
||
}
|
||
|
||
alias makedccmenu {
|
||
menu -dccgl
|
||
menu dccgl
|
||
if (dccitem(1)) {
|
||
#add default when fixed
|
||
menuitem dccgl -d "Display DCC Items" { dcc }
|
||
menuitem dccgl separator
|
||
} else {
|
||
menuitem dccgl -d "No DCC's in progress" { dcc }
|
||
}
|
||
for (@ _gl.i = 1, _gl.x = dccitem($_gl.i), @ _gl.i++) {
|
||
if (word(0 $_gl.x) == [chat] || word(0 $_gl.x) == [raw]) {
|
||
submenu dccgl dccsubgl$_gl.i "~$_gl.i $toupper($word(0 $_gl.x)): $word(1 $_gl.x)"
|
||
} else {
|
||
submenu dccgl dccsubgl$_gl.i "~$_gl.i $toupper($word(0 $_gl.x)): $word(1 $_gl.x) \($file.sanspath($word(8 $_gl.x))\)" gl $_gl.i
|
||
}
|
||
menuitem dccsubgl$_gl.i -d "Display" { dcc }
|
||
if (xdcc.isoktopreview($file.sanspath($word(8 $_gl.x)))) {
|
||
menuitem dccsubgl$_gl.i "~Preview Image" { previewbynum $word(9 $_gl.x) }
|
||
}
|
||
menuitem dccsubgl$_gl.i "Close" { //dcc close $word(9 $_gl.x) }
|
||
}
|
||
purge _gl
|
||
menu dccgl -reset
|
||
}
|
||
|
||
makedccmenu
|
||
|
||
alias makecdcc {
|
||
menu -cdcc
|
||
menu cdcc
|
||
^submenu cdcc dccgl -s "Current DCC Items"
|
||
^submenu cdcc cdccoff "Offers..."
|
||
^menuitem cdccoff "Create New offer" {cdcc offer}
|
||
^menuitem cdccoff "Remove an Existing offer" {cdcc doffer}
|
||
^menuitem cdccoff "List your offers (local)" {cdcc list}
|
||
^menuitem cdccoff "Notify Current Channel" {cdcc notice}
|
||
^menuitem cdccoff "Show channel your offers" {cdcc plist}
|
||
^menuitem cdccoff separator
|
||
^menuitem cdccoff "Save Offer File" {cdcc save}
|
||
^menuitem cdccoff "Reload Offer File" {cdcc load}
|
||
^menuitem cdcc separator
|
||
^menuitem cdcc "Create DCC ~Window" {/window create level dcc}
|
||
^menuitem cdcc "Send File(s)" { mansenddialog }
|
||
^menuitem cdcc "ReSend File(s)" { manresenddialog }
|
||
}
|
||
|
||
alias manserv {
|
||
@ _kat = [$"Enter Server name: "]
|
||
if (_kat) {//^server $_kat}
|
||
^assign -_kat
|
||
}
|
||
|
||
alias manservn {
|
||
@ _kat = [$"Enter Server name: "]
|
||
if (_kat) {//^window create server $_kat}
|
||
^assign -_kat
|
||
}
|
||
|
||
alias makemesgs {
|
||
^menuitem msgs "Read Message log" {/readlog}
|
||
^menuitem msgs "Delete Message log" {/remlog}
|
||
}
|
||
|
||
alias makebx {
|
||
^submenu bx bxmdi "MDI Window..."
|
||
^menuitem bxmdi "MDI On" {/set MDI on}
|
||
^menuitem bxmdi "MDI Off" {/set MDI off}
|
||
^menuitem bx separator
|
||
^menuitem bx "Paste" {/pmpaste}
|
||
^menuitem bx "Paste to input" {/pmpaste -input}
|
||
^menuitem bx "SmartPaste" {/pmpaste -smart}
|
||
^menuitem bx separator
|
||
^menuitem bx "Play a sound" {/dialogplaysound}
|
||
^menuitem bx separator
|
||
^menuitem bx "Show Version" {/sv}
|
||
}
|
||
|
||
alias makewindows {
|
||
^menuitem window "New Window" {/window create}
|
||
^menuitem window "Describe Window" {/window describe}
|
||
}
|
||
|
||
alias makehelp {
|
||
^menuitem help "Help" {/help}
|
||
^menuitem help "Extended Help" {/bhelp index}
|
||
^menuitem help separator
|
||
^menuitem help "About" {/about}
|
||
}
|
||
|
||
alias redraw_menus {
|
||
for (@ idx = 1, (win = winitem($idx)) && !done, @ idx++) {
|
||
if (win) {
|
||
if ([$word(6 $win)]!=[<none>]) {
|
||
^window $word(0 $win) menu $word(6 $win)
|
||
}
|
||
} else {@ done = 1}
|
||
}
|
||
^assign -done;^assign -win;^assign -idx
|
||
}
|
||
|
||
alias makepopup {
|
||
@ gt.ppnick = [$1]
|
||
@ gt.ppchan = [$0]
|
||
|
||
menu -popup
|
||
menu popup
|
||
//submenu popup md "$gt.ppnick"
|
||
//menuitem md "Op (+o)" {op $gt.ppnick}
|
||
//menuitem md "DeOp (-o)" {deop $gt.ppnick}
|
||
//menuitem md "Voice (+v)" {voice $gt.ppnick}
|
||
//menuitem md "Quiet (-v)" {quiet $gt.ppnick}
|
||
##Add some cool ignore stuff here.
|
||
//menuitem md "Ignore (temp)" {ig $gt.ppnick all}
|
||
//menuitem md "Ignore (perm)" {ig $gt.ppnick -p all}
|
||
//menuitem md "Unignore" {unig $gt.ppnick all}
|
||
##Do it right
|
||
//submenu popup nxdcc "XDCC"
|
||
//menuitem nxdcc -d "Req Pack List" {msg $gt.ppnick xdcc list}
|
||
//menuitem nxdcc separator
|
||
for (@ _xidx = 1, _xidx <= 15, @ _xidx++) {
|
||
//submenu nxdcc nx$_xidx "Pack #$_xidx "
|
||
//menuitem nx$_xidx "List" msg $gt.ppnick xdcc list #$_xidx
|
||
//menuitem nx$_xidx -d "Send" msg $gt.ppnick xdcc send #$_xidx
|
||
//menuitem nx$_xidx "ReSend" msg $gt.ppnick xdcc resend #$_xidx
|
||
}
|
||
|
||
//menuitem popup "Send File(s)" {senddialog $gt.ppnick}
|
||
//menuitem popup "ReSend File(s)" {resenddialog $gt.ppnick}
|
||
//menuitem popup "Send Sound" {dialogsound $gt.ppnick}
|
||
//submenu popup popother "Other"
|
||
//menuitem popother -d "Whois" {whois $gt.ppnick}
|
||
//menuitem popother "Server Whois" {wii $gt.ppnick}
|
||
//menuitem popother "Lookup" {nslookup $gt.ppnick}
|
||
//menuitem popother "Channel Idletime" {/showidle}
|
||
//menuitem popother separator
|
||
//menuitem popother "Talk (query)" {talk $gt.ppnick}
|
||
//menuitem popother "Chat (dcc chat query)" {chat $gt.ppnick}
|
||
//menuitem popother separator
|
||
//menuitem popother "Ping" {ping $gt.ppnick}
|
||
//menuitem popother "Time" {/ctcp $gt.ppnick TIME}
|
||
//menuitem popother "UserInfo" {/ctcp $gt.ppnick userinfo}
|
||
//menuitem popother "Finger" {/ctcp $gt.ppnick finger}
|
||
//menuitem popother "Version" {ver $gt.ppnick}
|
||
//menuitem popup separator
|
||
//submenu popup kicks "Kicks"
|
||
//menuitem kicks -d "Random Kick" {k $gt.ppnick}
|
||
//menuitem kicks "McKick" {mck $gt.ppnick}
|
||
//menuitem kicks "McKick (break)" {mcdk $gt.ppnick}
|
||
//menuitem kicks "TacobellKick" {tbk $gt.ppnick}
|
||
//menuitem kicks "BurgerKing Kick" {bkk $gt.ppnick}
|
||
//menuitem kicks "KentuckyFried" {kfck $gt.ppnick}
|
||
//menuitem kicks "CarlsJr Kick" {cjk $gt.ppnick}
|
||
//menuitem kicks "TaeKwonLeap Kick" {tkl $gt.ppnick}
|
||
//menuitem kicks "GreetKick" {gk $gt.ppnick}
|
||
if (gz.extras) //menuitem kicks -b "PimpKick" {pimpkick $gt.ppnick}
|
||
if (gz.extras) //menuitem kicks "PimpSlap" {pimpslap $gt.ppnick}
|
||
if (gz.extras) //menuitem kicks "GerbilKick" {gerbilkick $gt.ppnick}
|
||
if (gz.extras) //menuitem kicks "GimpKick" {gimpkick $gt.ppnick}
|
||
if (gz.extras) //menuitem kicks "Stinkkick" {stinkkick $gt.ppnick}
|
||
if (gz.extras) //menuitem kicks "LamahKick" {lamahkick $gt.ppnick}
|
||
if (gz.extras) //menuitem kicks "Soup Kick" {soupkick $gt.ppnick}
|
||
//submenu popup popban "Bans"
|
||
//menuitem popban "Ban" {ban $gt.ppnick}
|
||
//menuitem popban -d "Ban/Kick" {bk $gt.ppnick}
|
||
//menuitem popban "Kick/Ban/Ignore" {kbi $gt.ppnick}
|
||
//menuitem popban separator
|
||
//menuitem popban "Screw Ban" {sban $gt.ppnick}
|
||
//menuitem popban "Screw Ban/Kick" {sban $gt.ppnick;k $gt.ppnick}
|
||
//menuitem popban "Screw Ban/Kick/Ignore" {sban $gt.ppnick;k $gt.ppnick;ig $gt.ppnick}
|
||
//menuitem popup separator
|
||
//submenu popup popnotify "Notify..."
|
||
//menuitem popnotify "Add to Notify list" {//notify $gt.ppnick}
|
||
//menuitem popnotify "Remove from Notify List" {//notify -$gt.ppnick}
|
||
//menuitem popnotify "Show Notify List" {//notify}
|
||
//submenu popup poppaste "Clipboard"
|
||
//menuitem poppaste -d "Paste" {//pmpaste}
|
||
//menuitem poppaste "SmartPaste" {//pmpaste -smart}
|
||
//menuitem popup separator
|
||
//submenu popup actions "Actions"
|
||
//submenu actions cluebats "ClueBats"
|
||
//menuitem cluebats "Clue Bludgeon" {/me bludgeons $gt.ppnick with the cluebat}
|
||
//menuitem cluebats "Lead ClueBat" {/me pulls out a lead cluebat, engraves $gt.ppnick's name on it, and swings wildly}
|
||
//menuitem cluebats "Pi<50>ata" {/me strings $gt.ppnick up, puts on a blindfold, and declares a cluebat pi<70>ata party!!!}
|
||
//menuitem cluebats "SuperMomoCluebat" {/me purchases a sUpErMoMo (tm) cluebat and pummels $gt.ppnick to the ground}
|
||
//menuitem cluebats "Windows Cluebat" {/me finds the Windows edition Cluebat, taps it over $gt.ppnick's head, and watches it break}
|
||
//menuitem actions separator
|
||
//menuitem actions "Awake?" {/me pokes $gt.ppnick in the ribs ... you awake?}
|
||
//menuitem actions "Backside" {/me calls attention to $gt.ppnick's backside}
|
||
//menuitem actions "Booger" {/me flicks a booger at $gt.ppnick}
|
||
//menuitem actions "Cookie Toss" {/me tosses $gt.ppnick a cookie... good boy }
|
||
//menuitem actions "Curse" {/me wishes the fleas of a thousand camels upon $gt.ppnick's underwear drawer.}
|
||
//menuitem actions "Fart" {/me farts in $gt.ppnick's general direction, clearing $gt.ppchan as well.}
|
||
//menuitem actions "Finger" {/me gives $gt.ppnick the finger. nInn}
|
||
//menuitem actions "Glare" {/me glares at $gt.ppnick}
|
||
//submenu actions ctacts -b "Cute Actions"
|
||
//menuitem ctacts "Hug" {/me hugs $gt.ppnick ....}
|
||
//menuitem ctacts "Pass Kiss" {/me Passionately Kisses $gt.ppnick}
|
||
//menuitem ctacts "Hug/Kiss" {/me Hugs and Kisses $gt.ppnick}
|
||
//menuitem ctacts "Dance" {/me takes $gt.ppnick in hand and Dances $rgenderex() around the channel}
|
||
//menuitem ctacts "OZ-Hug" {/me gives $gt.ppnick a Big Ole Ozzie hug....}
|
||
//menuitem ctacts "Rose" {/me drops to $gender knees and hands $gt.ppnick a long stemed rose @>->-`-,-->---}
|
||
//menuitem ctacts "Snuggle" {/me snuggles up to $gt.ppnick ....}
|
||
//menuitem actions separator
|
||
//menuitem actions "HerringSlap" {/me slaps $gt.ppnick around a bit with an official sized #os/2 herring...}
|
||
//menuitem actions "Noogie" {/me noogies $gt.ppnick}
|
||
//menuitem actions "Nosepicker" {/me watches in disgust, as $gt.ppnick picks their nose}
|
||
//menuitem actions "Slap" {/me slaps $gt.ppnick around a bit with a substantially large Brown Cow...}
|
||
//menuitem actions "Moon" {/me drops $gender drawers and moons $gt.ppnick ( | )}
|
||
//menuitem actions "PoopFace" {say Hey $gt.ppnick does the expression "Up your Bum PoopFace" Mean anything to you ??? :P}
|
||
//menuitem actions "Rose" {/me tosses $gt.ppnick a rose @>--`-}
|
||
//menuitem actions "Smurf" {/me points at $gt.ppnick and calls him a 09SMURF07}
|
||
//submenu actions deaths -b "Deaths"
|
||
//menuitem deaths "AK47" {/me pulls out $gender trusty AK47... nestles the sites squarely on $gt.ppnick's head... eases back on the trigger and empties a 30 round clip.... BANG You're Dead}
|
||
//menuitem actions separator
|
||
//menuitem actions "Sneeze" {/me sneezes violently and a blob of snot lands on $gt.ppnick}
|
||
//menuitem actions "Thwap" {/me thwaps $gt.ppnick upside the head... \"Get with the program.\"}
|
||
//menuitem actions "Tickle" {/me sneaks up behind $gt.ppnick ... tickle tickle tickle...}
|
||
//menuitem actions "Wet Noodle" {/me pummels $gt.ppnick with a wet noodle}
|
||
//menuitem actions "Whistle" {/me whistles with an innocent look on $gender face...}
|
||
//menuitem actions "Win95 Torture" {/me handcuffs $gt.ppnick to a desk with Windows95 - "Multitask, bitch."}
|
||
//menuitem actions "Vomit upon" {/me vomits repeatedly upon $gt.ppnick}
|
||
//menuitem actions "Yucko" {/me slids over close to $gt.ppnick and gives them a nice slimey YUCKO !!!!}
|
||
//submenu popup greets "Greets"
|
||
//menuitem greets "moo" {say moo $gt.ppnick}
|
||
//menuitem greets "\'lo" {say 'lo $gt.ppnick}
|
||
//menuitem greets "heya" {say heya $gt.ppnick}
|
||
//menuitem greets "what's up" {say what's up $gt.ppnick}
|
||
//menuitem greets "re" {say re $gt.ppnick}
|
||
//menuitem greets "hi" {say hi $gt.ppnick}
|
||
//menuitem greets "Yo" {say Yo!! $gt.ppnick\!}
|
||
//menuitem greets "hello" {say hello $gt.ppnick}
|
||
//menuitem greets "Howdy" {say Howdy $gt.ppnick}
|
||
//menuitem greets "\'sup?" {say \'sup $gt.ppnick\?}
|
||
//menuitem greets "!!!!!" {say $gt.ppnick!!!!!}
|
||
//menuitem greets "!@#\$\%\^" {say $gt.ppnick\!@#\$\%\^}
|
||
//submenu popup byes "Byes"
|
||
//menuitem byes "bye" {say bye $gt.ppnick}
|
||
//menuitem byes "hastalapasta" {say hastalapasta $gt.ppnick}
|
||
//menuitem byes "hastalabyebye" {say Hastalabyebye $gt.ppnick}
|
||
//menuitem byes "wave" {/me waves bye to $gt.ppnick\. \"Don't let the door hit you in the arse\"}
|
||
//menuitem byes "See ya" {say See ya $gt.ppnick}
|
||
if ([$loadacts]==[YES]) {
|
||
/loadplug $actionsfile
|
||
}
|
||
^popupmenu popup
|
||
}
|
||
|
||
alias rccheck {
|
||
if (onchannel($lastclickline(4) $C)==1) {makepopup $C $lastclickline(4)} else {windowlist}
|
||
}
|
||
|
||
alias ldccheck {
|
||
if (onchannel($lastclickline(4) $C)==1) {talk $lastclickline(4)}
|
||
}
|
||
|
||
alias logstart {
|
||
@ cc = [$0]
|
||
filedialog S $exedir/*.log "Logfile for $cc" "Set" {
|
||
if ([$0]==[OK]) {
|
||
^cset CHANNEL_LOG_FILE $decode($1-)
|
||
^cset CHANNEL_LOG on
|
||
gecho Logging of $cc to $decode($1-) now active.
|
||
}
|
||
}
|
||
}
|
||
|
||
alias logchange {
|
||
@ cc = [$0]
|
||
if ([$getcset(CHANNEL_LOG $cc)]!=[ON]) {
|
||
filedialog S $exedir/*.log "Logfile for $cc" "Set" {
|
||
if ([$0]==[OK]) {
|
||
^cset CHANNEL_LOG_FILE $decode($1-)
|
||
gecho Log file for $cc changed to $decode($1-).
|
||
}
|
||
}
|
||
} else {gecho You must turn Logging off before changing the log file}
|
||
}
|
||
|
||
alias logstop {
|
||
@ cc = [$0]
|
||
^cset CHANNEL_LOG OFF
|
||
gecho Log file $getcset(CHANNEL_LOG_FILE $cc) for $cc now closed.
|
||
}
|
||
|
||
alias gz.ajoinlist {
|
||
for (@ idx = 0, ajoinitem($idx), @ idx++) {
|
||
push _ret $ajoinitem($idx)
|
||
}
|
||
#@function_return = $_ret
|
||
return $_ret
|
||
purge _ret
|
||
}
|
||
|
||
alias inajoinlist {
|
||
@ function_return = match($0 $gz.ajoinlist()) ? 1 : 0
|
||
}
|
||
|
||
#Popup Channel Menu inspired by menus.scr by OS3
|
||
alias chanmenu {
|
||
@ cc = [$0]
|
||
menu -popcm
|
||
menu popcm
|
||
if (match($cc $mychannels())) {
|
||
if (cc != T) {//menuitem popcm "goto $cc window" /j $cc}
|
||
//menuitem popcm \"~Leave: $cc\" {leave $cc}
|
||
} else {//menuitem popcm \"~Join: $cc\" {join $cc}}
|
||
if (inajoinlist($cc)) {
|
||
//menuitem popcm "~Remove from AJoin" {unajoin $cc}
|
||
} else {
|
||
//menuitem popcm "~Add to AJoin" {ajoin $cc}
|
||
}
|
||
if (match($cc $mychannels())) {
|
||
if ([$getcset(CHANNEL_LOG $cc)]==[ON]) {
|
||
menuitem popcm "Stop Logging" { logstop $cc }
|
||
} else {
|
||
menuitem popcm "Start Logging" { logstart $cc $1- }
|
||
}
|
||
menuitem popcm "Change Logfile" { logchange $cc $1- }
|
||
}
|
||
if (![$1]) {
|
||
menuitem popcm separator
|
||
//submenu popcm cmm "Channel Stats"
|
||
if (gz.longcsc) {
|
||
//menuitem cmm -d "Names (detailed)" {/scan}
|
||
//menuitem cmm "Names (short)" {cnames}
|
||
} else {
|
||
//menuitem cmm -d "Names (short)" {cnames}
|
||
//menuitem cmm "Names (detailed)" {/scan}
|
||
}
|
||
//menuitem cmm "Who (Detailed)" {cwho}
|
||
//menuitem cmm "Show Channel Bans" {csb}
|
||
//menuitem cmm "Show Channel Topic" {t}
|
||
//submenu popcm cmodes "Modes"
|
||
//menuitem cmodes "Show Modes" {gecho Mode For $cc is \+$chanmode($cc)}
|
||
//menuitem cmodes "Remove Keys (unlock)" {unlock}
|
||
//submenu cmodes csetmode "Set Modes"
|
||
//menuitem csetmode "Mode (+nst)" {/mode $cc +nst}
|
||
//menuitem csetmode "Mode (+inst)" {/mode $cc +inst}
|
||
//submenu cmodes creset "Reset Modes"
|
||
//menuitem creset "Reset (+nst)" {/creset}
|
||
//menuitem creset "Reset (+inst)" {/creseti}
|
||
//submenu cmodes cmass "Mass"
|
||
//menuitem cmass "Mass Op (+o)" {mop}
|
||
//menuitem cmass "Mass DeOp (-o)" {mdop}
|
||
//menuitem cmass "Mass Voice (+v)" {mvoice}
|
||
//menuitem cmass "Mass UnVoice (-v)" {mdvoice}
|
||
//menuitem popcm separator
|
||
//submenu popcm credir "Redirects"
|
||
//submenu credir lrm "Last Received Message"
|
||
//menuitem lrm "=> Channel" {relm}
|
||
//menuitem lrm "=> Topic" {relmt}
|
||
//submenu credir lrn "Last Received Notice"
|
||
//menuitem lrn "=> Channel" {reln}
|
||
//menuitem lrn "=> Topic" {relnt}
|
||
//submenu credir lsm "Last Sent Message"
|
||
//menuitem lsm "=> Channel" {relsm}
|
||
//menuitem lsm "=> Topic" {relsmt}
|
||
//submenu credir lsn "Last Sent Notice"
|
||
//menuitem lsn "=> Channel" {relsn}
|
||
//menuitem lsn "=> Topic" {relsnt}
|
||
//submenu popcm other "Other"
|
||
//menuitem other "Channel Away" {away -c}
|
||
//menuitem other "Channel Back" {cback}
|
||
//menuitem other "Cycle" {cycle}
|
||
//menuitem other "Check Offers" {/ctcp $cc xdcc list}
|
||
//menuitem other "Check ctcp Time" {/ctcp $cc time}
|
||
//menuitem popcm "Send Sound" dialogsound $cc
|
||
//menuitem popcm separator
|
||
//submenu popcm cgreets "Greets"
|
||
//menuitem cgreets "moo" {/say moo!}
|
||
//menuitem cgreets "zug zug" {/say zug zug}
|
||
//menuitem cgreets "Hey all" {/say Hey all}
|
||
//menuitem cgreets "'lo" {/say 'lo}
|
||
//menuitem cgreets "What's up folks?" {/say What's up folks?}
|
||
//submenu popcm cacts "Actions"
|
||
//menuitem cacts "Binoculars" {/me pulls out $gender binoculars and searches $cc for intelligent life.... Damn... None to be found!}
|
||
//menuitem cacts "Gerbil Release" {/me releases $gender gerbils upon $cc, run while you can!!!}
|
||
//menuitem cacts "PinDrop" {/me drops the proverbial pin...}
|
||
//menuitem cacts "Slide" {/me slides into the channel... dances a happy jig... falls on $gender arse in the process}
|
||
//submenu popcm cbyes "Byes"
|
||
//menuitem cbyes "Later all" {/say Later all}
|
||
//menuitem popcm separator
|
||
//menuitem popcm "Ping" {ping $CC}
|
||
//menuitem popcm "Version" {ver $CC}
|
||
}
|
||
popupmenu popcm
|
||
#^assign -cc
|
||
}
|
||
|
||
alias targetmenu {
|
||
menu -tm
|
||
menu tm
|
||
if (![$1]) {
|
||
menuitem tm "Queried: $0 " #
|
||
} else {
|
||
menuitem tm "nick: $0 " #
|
||
}
|
||
menuitem tm separator
|
||
if (![$1]) {
|
||
menuitem tm "Turn Log On" {//^window logfile $exedir/logs/$left(8 $strip(=\\*?<>|\"\' $T)).log;//window log on}
|
||
menuitem tm "Turn Log off" //window log off
|
||
} else {
|
||
menuitem tm "Talk Window" /talk $0
|
||
menuitem tm "Chat Window" /chat $0
|
||
}
|
||
submenu tm tmi "Ignores"
|
||
menuitem tmi -d "Ignore (temp)" ig $0 -t 180 all
|
||
menuitem tmi "Ignore (perm)" ig $0 -p all
|
||
menuitem tmi "Unignore" unig $0 all
|
||
//submenu tm tmo "Other"
|
||
//menuitem tmo -d "Whois" whois $0
|
||
//menuitem tmo "Server Whois" wii $0
|
||
//menuitem tmo "Lookup" nslookup $0
|
||
//menuitem tmo separator
|
||
//menuitem tmo "Ping" ping $0
|
||
//menuitem tmo "Time" ctcp $0 TIME
|
||
//menuitem tmo "UserInfo" ctcp $0 userinfo
|
||
//menuitem tmo "Finger" ctcp $0 finger
|
||
//menuitem tmo "Version" ver $0
|
||
//submenu tm tmx "XDCC"
|
||
//menuitem tmx -d "Req Pack List" msg $0 xdcc list
|
||
//menuitem tmx separator
|
||
for (@ _xidx = 1, _xidx <= 15, @ _xidx++) {
|
||
//submenu tmx tmx$_xidx "Pack #$_xidx "
|
||
//menuitem tmx$_xidx "List" msg $0 xdcc list #$_xidx
|
||
//menuitem tmx$_xidx -d "Send" msg $0 xdcc send #$_xidx
|
||
//menuitem tmx$_xidx "ReSend" msg $0 xdcc resend #$_xidx
|
||
}
|
||
//menuitem tm "Send File(s)" senddialog $0
|
||
//menuitem tm "ReSend File(s)" resenddialog $0
|
||
//menuitem tm "Send Sound" dialogsound $0
|
||
popupmenu tm
|
||
^assign -_xidx
|
||
}
|
||
|
||
alias windowlist {
|
||
@ _ll.l = lastclickline(0)
|
||
if (![$0]) {@ _cw = lastclickline(3);@ __cw = lastclickline(4)} else {@ _cw = []}
|
||
if ((word(2 $_ll.l) == [SOUND:]) && (![$0]) && (word(4 $_ll.l) == [\(autorequest])) {
|
||
menu -tmpmenu
|
||
menu tmpmenu
|
||
if (gz.mircsndpatch) {
|
||
//^quote PRIVMSG $1 :!$0 $3
|
||
menuitem tmpmenu "request Sound [$word(3 $_ll.l)]" { /msg $C !$word(1 $_ll.l) $word(3 $_ll.l) }
|
||
} else {
|
||
menuitem tmpmenu "request Sound [$word(3 $_ll.l)]" { /msg $word(1 $_ll.l) !$word(1 $_ll.l) $word(3 $_ll.l) }
|
||
}
|
||
# menuitem tmpmenu "request Sound [$word(3 $_ll.l)]" { /msg $word(1 $_ll.l) !$word(1 $_ll.l) $word(3 $_ll.l) }
|
||
popupmenu tmpmenu
|
||
} else if ((rmatch($_cw *.??*)) && (@_cw > 4)) {
|
||
# if (!rmatch($_cw http:// ftp:// gopher://)) {@_cw=[http://]##_cw}
|
||
urlmenu $_cw;^assign -_cw
|
||
# } else if (ischannel($strip(@\'\"\(\) $_cw))) {chanmenu $strip(@\'\"\(\) $_cw) -d;^assign -_cw
|
||
} else if (ischannel($gz.safechan($_cw))) {chanmenu $gz.safechan($_cw) -d;^assign -_cw
|
||
# } else if (ischannel($strip(+@\'\"\(\) $_cw))) {chanmenu $_cw -d;^assign -_cw}
|
||
} else if (__cw == T && [$T]!=[]) {targetmenu $T
|
||
} else {
|
||
menu -menulist
|
||
menu menulist
|
||
#submenu menulist setup -s "Setup"
|
||
//submenu menulist pastepop "Clipboard"
|
||
//menuitem pastepop -d "Paste" {//pmpaste}
|
||
//menuitem pastepop "SmartPaste" {//pmpaste -smart}
|
||
# if (lastclickline(3)) {
|
||
# //submenu menulist webster "Dictionary"
|
||
# //menuitem webster "Define: $strip(\[\]!@#$%^&*\(\)-_=+\\|,.<>\/?~`\" $lastclickline(3))" define $strip(\[\]!@#$%^&*\(\)-_=+\\|,.<>\/?~`\" $lastclickline(3))
|
||
# //menuitem webster "Spell: $strip(\[\]!@#$%^&*\(\)-_=+\\|,.<>\/?~`\" $lastclickline(3))" spell $strip(\[\]!@#$%^&*\(\)-_=+\\|,.<>\/?~`\" $lastclickline(3))
|
||
# }
|
||
//submenu menulist popsave "Save..."
|
||
//menuitem popsave "Save All" {
|
||
/save
|
||
/cdcc save
|
||
}
|
||
//menuitem popsave "Save BitchX Settings" {/save}
|
||
//menuitem popsave "Save CDCC Pack List" {/cdcc save}
|
||
//menuitem menulist "Change Font" {fontdialog 0 0}
|
||
makedccmenu
|
||
submenu menulist subdcc "Current DCC Items"
|
||
if (dccitem(1)) {
|
||
#add default when fixed
|
||
menuitem subdcc -d "Display DCC Items" dcc
|
||
menuitem subdcc separator
|
||
} else {
|
||
menuitem subdcc -d "No DCC's in progress" dcc
|
||
}
|
||
for (@ _gl.i = 1, _gl.x = dccitem($_gl.i), @ _gl.i++) {
|
||
if (word(0 $_gl.x) == [chat] || word(0 $_gl.x) == [raw]) {
|
||
submenu subdcc subdccsubgl$_gl.i "~$_gl.i $toupper($word(0 $_gl.x)): $word(1 $_gl.x)"
|
||
} else {
|
||
submenu subdcc subdccsubgl$_gl.i "~$_gl.i $toupper($word(0 $_gl.x)): $word(1 $_gl.x) \($file.sanspath($word(8 $_gl.x))\)" gl $_gl.i
|
||
}
|
||
menuitem subdccsubgl$_gl.i -d "Display" dcc
|
||
if (xdcc.isoktopreview($file.sanspath($word(8 $_gl.x)))) {
|
||
menuitem subdccsubgl$_gl.i "~Preview Image" { previewbynum $word(9 $_gl.x) }
|
||
}
|
||
menuitem subdccsubgl$_gl.i "Close" { //dcc close $word(9 $_gl.x) }
|
||
}
|
||
purge _gl
|
||
//menuitem menulist "Show Notify" {//notify}
|
||
//menuitem menulist separator
|
||
//menuitem menulist "Properties" {/properties}
|
||
//menuitem menulist separator
|
||
//menuitem menulist " << Window list >> " #
|
||
@ done = 0
|
||
for (@ idx = 1, (win = winitem($idx)) && !done, @ idx++) {
|
||
if (win) {
|
||
if ([$word(3 $win)]!=[<none>]) {
|
||
//menuitem menulist "~$idx $word(3 $win) [$word(0 $win)]" { //window show $word(0 $win) }
|
||
} else if ([$word(4 $win)!=[<none>]) {
|
||
//menuitem menulist "~$idx $word(4 $win) [$word(0 $win)]" { //window show $word(0 $win) }
|
||
} else {
|
||
//menuitem menulist "~$idx $word(1 $win) [$word(0 $win)]" { //window show $word(0 $win) }
|
||
}
|
||
} else {@ done = 1}
|
||
}
|
||
popupmenu menulist
|
||
}
|
||
^assign -_cw;^assign -__cw
|
||
^assign -done
|
||
}
|
||
|
||
alias urlmenu {
|
||
@ url = [$strip(\(\)\" $0)]
|
||
if (url) {
|
||
menu -wm
|
||
menu wm
|
||
//submenu wm wm3 "Netscape"
|
||
//menuitem wm3 -d \"$left(100 $url)\" webfix netscape $url
|
||
//submenu wm wm1 "WebExplorer"
|
||
//menuitem wm1 -d \"$left(100 $url)\" webfix webexplorer $url
|
||
//submenu wm wm2 "Lynx"
|
||
//menuitem wm2 -d \"$left(100 $url)\" exec -start LYNX $url
|
||
//menuitem wm separator
|
||
//submenu wm wmh "Add to URL Save File"
|
||
//menuitem wmh -d \"$left(100 $url)\" addtofile $url
|
||
//submenu wm wmc "Copy URL to clipboard"
|
||
//menuitem wmc -d \"$left(100 $url)\" clipbrdput $url
|
||
popupmenu wm
|
||
}
|
||
^assign -url
|
||
}
|
||
|
||
alias webfix {
|
||
@ _weblist = [$webrun($0)]
|
||
if (_weblist) {
|
||
@ webrun(activate $word(0 $_weblist))
|
||
@ webrun($0 pushurl $word(0 $_weblist) $1)
|
||
} else {
|
||
if ([$0]==[webexplorer]) {/exec -noshell explore.exe $1}
|
||
if ([$0]==[netscape]) {/exec -start netscape $browserparams $1}
|
||
}
|
||
^assign -_weblist
|
||
}
|
||
|
||
#OS2-Mike's idea and code stub.
|
||
alias dialogsound {
|
||
@ gt.sndnick = [$0]
|
||
if (ischannel($gt.sndnick)) {
|
||
filedialog OA $sounddir/*.* "Send Sound Files" "Send/Exit" "Send" {
|
||
if ([$0]==[OK]) {/csound $gt.sndnick $decode($1);^assign -gt.sndnick}
|
||
if ([$0]==[APPLY]) {/csound $gt.sndnick $decode($1)}
|
||
if ([$0]==[CANCEL]) {^assign -gt.sndnick}
|
||
}
|
||
} else {
|
||
filedialog OA $sounddir/*.* "Send Sound Files" "Send/Exit" "Send" {
|
||
if ([$0]==[OK]) {
|
||
if (ctcpsnd.localfile($decode($1))) {
|
||
/mmpm.playfile $ctcpsnd.fname
|
||
//ctcp $gt.sndnick SOUND $decode($1)
|
||
^assign -gt.sndnick
|
||
}
|
||
}
|
||
if ([$0]==[APPLY]) {
|
||
if (ctcpsnd.localfile($decode($1))) {
|
||
/mmpm.playfile $ctcpsnd.fname
|
||
//ctcp $gt.sndnick SOUND $decode($1)
|
||
}
|
||
}
|
||
if ([$0]==[CANCEL) {
|
||
^assign -gt.sndnick
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
alias dialogplaysound {
|
||
filedialog OA $sounddir/*.* "Play Sound Files" "Play" "Test" {
|
||
if ([$0]==[OK]) {
|
||
if (ctcpsnd.localfile($decode($1))) {
|
||
/mmpm.playfile $ctcpsnd.fname
|
||
^assign -gt.sndnick
|
||
}
|
||
}
|
||
if ([$0]==[APPLY]) {
|
||
if (ctcpsnd.localfile($decode($1))) {
|
||
/mmpm.playfile $ctcpsnd.fname
|
||
}
|
||
}
|
||
if ([$0]==[CANCEL) {
|
||
^assign -gt.sndnick
|
||
}
|
||
}
|
||
}
|
||
|
||
alias senddialog {//filedialog OM $gx.uploaddir\* "Select Files to send" sendproc send $0 $$*}
|
||
alias resenddialog {//filedialog OM $gx.uploaddir\* "Select Files to send" sendproc resend $0 $$*}
|
||
|
||
alias sendproc {
|
||
if ([$2] == [OK]) {
|
||
@ _sp.f = 0
|
||
fe ($3-) _sp.t {
|
||
if (fexist($decode($3-)) == 1) {
|
||
//dcc $0 $1 $decode($3-)
|
||
@ _sp.f = 1
|
||
}
|
||
}
|
||
if (_sp.f) {gecho File Request sent to $1}
|
||
purge _sp
|
||
}
|
||
}
|
||
|
||
alias mansenddialog {//filedialog OM $gx.uploaddir\* "Select Files to send" mansendproc send $$*}
|
||
alias manresenddialog {//filedialog OM $gx.uploaddir\* "Select Files to send" mansendproc resend $$*}
|
||
|
||
alias mansendproc {
|
||
if ([$1] == [OK]) {
|
||
@ _sp.n = [$"[gxDCC] Nick to send to : "]
|
||
if (_sp.n) {
|
||
@ _sp.f = 0
|
||
fe ($2-) _sp.t {
|
||
if (fexist($decode($_sp.t)) == 1) {
|
||
//dcc $0 $_sp.n $decode($_sp.t)
|
||
@ _sp.f = 1
|
||
}
|
||
}
|
||
}
|
||
if (_sp.f) {gecho File Request sent to $_sp.n}
|
||
purge _sp
|
||
}
|
||
}
|
||
|
||
#on ^hook "dccchanged*" {
|
||
# makedccmenu
|
||
# /redraw_menus
|
||
# }
|
||
|
||
#on #-dcc_connect 23 "*" {^hook dccchanged}
|
||
#on #-dcc_lost 23 "*" {^hook dccchanged}
|
||
#on #-dcc_request 23 "*" {^hook dccchanged}
|
||
|
||
#^on ^connect "*" {
|
||
# makemenu
|
||
# /redraw_menu
|
||
#}
|
||
|
||
^on #^timer 60 * {
|
||
if (rmatch($0 %:00*) || match($0 %:30*) || match($0 %:15*) || match($0 %:45*)) {
|
||
for (@ idx = 1, (win = winitem($idx)), @ idx++) {
|
||
if (win) {xecho -b -window $word(0 $win) The Time is now $0} }
|
||
}
|
||
}
|
||
|
||
alias gz.sndon {
|
||
if (ctcpsound == [OFF]) {
|
||
@ function_return = 0
|
||
} else {
|
||
if (away && gz.noctcpaway) {
|
||
@ function_return = 0
|
||
} else {
|
||
@ function_return = isctog($0 S) ? 0 : 1
|
||
}
|
||
}
|
||
}
|
||
|
||
alias gz.reqon {
|
||
if (ctcpsndreq == [OFF]) {
|
||
@ function_return = 0
|
||
} else {
|
||
if (away && gz.noctcpaway) {
|
||
@ function_return = 0
|
||
} else {
|
||
@ function_return = isctog($0 R) ? 0 : 1
|
||
}
|
||
}
|
||
}
|
||
|
||
on ^ctcp "% % SOUND *" {
|
||
@ _dl = []
|
||
if (rmatch($3 *.wav *.au *.mid) && [$3] && gz.sndon($1)) {
|
||
if (ctcpsnd.havefile($3)) {
|
||
# mmpm.playfile2 $gz.playifplaying $ctcpsnd.fname
|
||
mmpm.playfile $ctcpsnd.fname
|
||
} else {
|
||
if (!gz.reqon($1)) { @ _dl = [autorequest disabled]
|
||
} else if (ctcpsnd.isgetting($3)) { @ _dl = [downloading]
|
||
} else if (ctcpsnd.isrequested($3) < 30) { @ _dl = [requested]
|
||
} else {
|
||
if (gz.mircsndpatch) {
|
||
//^quote PRIVMSG $1 :!$0 $3
|
||
} else {
|
||
//^quote PRIVMSG $0 :!$0 $3
|
||
}
|
||
ctcpsnd.requested $3
|
||
@ _dl = [requesting]
|
||
}
|
||
}
|
||
if (ischannel($1)) {
|
||
//xecho -b -t $1 ${gc.nickaction}$0${cl}/$1 SOUND: $file.sanspath($3) ${_dl?[\($_dl\)]:[]} $mirc2cntl(,$4-)
|
||
} else {
|
||
//xecho -b ${gc.nickaction}$0${cl} SOUND: $file.sanspath($3) ${_dl?[\($_dl\)]:[]} $mirc2cntl(,$4-)
|
||
}
|
||
} else {
|
||
if (ischannel($1)) {
|
||
//xecho -b -t $1 ${gc.nickaction}$0${cl}/$1 SOUND: $file.sanspath($3) \(ctcp sounds disabled\) $mirc2cntl(,$4-)
|
||
} else {
|
||
//xecho -b ${gc.nickaction}$0${cl} SOUND: $file.sanspath($3) \(ctcp sounds disabled) $mirc2cntl(,$4-)
|
||
}
|
||
}
|
||
}
|
||
|
||
on ^hook "ctcpsnd received %*" {
|
||
if (ctcpsound == [on]) {
|
||
gecho Requested Sound Finished: $2-
|
||
# /mmpm.playfile2 $gz.playifplaying $2
|
||
/mmpm.playfile $2
|
||
}
|
||
}
|
||
|
||
on ^hook "ctcpsnd request % % *" {
|
||
gecho \($4\) file request from $3 ${[$2]?[sent]:[access denied]}
|
||
}
|
||
|
||
on #-send_msg 74 "% !% %.wav" ctcpsnd.request $2
|
||
on #-send_msg 74 "% !%.au" ctcpsnd.request $2
|
||
on #-send_msg 74 "% !%.mid" ctcpsnd.request $2
|
||
|
||
on #-send_notice 74 "% !% %.wav" ctcpsnd.request $2
|
||
on #-send_notice 74 "% !% %.au" ctcpsnd.request $2
|
||
on #-send_notice 74 "% !% %.mid" ctcpsnd.request $2
|
||
|
||
on #-send_public 74 "% !% %.wav" ctcpsnd.request $2
|
||
on #-send_notice 74 "% !% %.mid" ctcpsnd.request $2
|
||
on #-send_msg 74 "% !% %.au" ctcpsnd.request $2
|
||
|
||
alias sound {
|
||
if ([$0]) {
|
||
if (T) {
|
||
if (ischannel($T)) {@ _t = T} else {@ _t = strip(= $T)}
|
||
if (ctcpsnd.localfile($0)) {
|
||
# /mmpm.playfile2 $gz.playifplaying $ctcpsnd.fname
|
||
/mmpm.playfile $ctcpsnd.fname
|
||
/ctcp $_t SOUND $0-
|
||
if ([$1] != []) {
|
||
//xecho -b ${gc.action}$N${cl}/$T SOUND \($0\): $1-
|
||
} else {
|
||
//xecho -b ${gc.action}$N${cl}/$T SOUND \($0\)
|
||
}
|
||
} else {
|
||
gecho File $0 does not exist${index(\\/: $0) >= 0 ? [, please check your /set sound_path] : []}
|
||
}
|
||
} else {
|
||
gecho There are no channel or /query in this window
|
||
}
|
||
} else {
|
||
gecho Usage: /sound file.wav [</me like action>]
|
||
}
|
||
^assign -_t
|
||
}
|
||
|
||
alias csound {
|
||
if (ctcpsnd.localfile($1)) {
|
||
# /mmpm.playfile2 $gz.playifplaying $ctcpsnd.fname
|
||
/mmpm.playfile $ctcpsnd.fname
|
||
/ctcp $0 SOUND $1-
|
||
//xecho -b ${gc.action}$N${cl} SOUND \($1)
|
||
} else {
|
||
gecho File $1 does not exist
|
||
}
|
||
}
|
||
|
||
alias chat {
|
||
if ([$1]==[-b]) {@ _oink = gz.autotalkfg} else {@ _oink = 1}
|
||
if ([$0]) {
|
||
for (@ idx = 1, (win = winitem($idx)) && !done, @ idx++) {
|
||
if (win) {
|
||
if (word(4 $win)==[=$0]) {
|
||
gecho You already have a query to $0
|
||
@ borky = 1
|
||
}
|
||
} else {@ done = 1}
|
||
}
|
||
if (!borky) {
|
||
gecho ${gc.msginfo} Creating chat window with${cl} ${gc.msgfrom} $0${cl}
|
||
//^window create nicklist 0 query =$0
|
||
//dcc chat $0
|
||
if (autotalklogging == [ON]) {
|
||
switch ($gz.drivetype($gz.logdir)) {
|
||
(hpfs) {@ _talk.file = strip(\\*?<>|\"\' $0) ## [.log]}
|
||
(*) {@ _talk.file = left(8 $strip(\\*?<>|\"\' $0)) ## [.log]}
|
||
}
|
||
//^window $_moo logfile $gz.logdir\/$_talk.file
|
||
xecho -target $0 $gemz Window Logfile is $gz.logdir\/$_talk.file
|
||
//^window $_moo log on
|
||
xecho -target $0 $gemz Window LOG is ON
|
||
}
|
||
}
|
||
} else {gecho Usage talk <nick>}
|
||
^assign -done;^assign -borky;^assign -_moo;^assign -_oink
|
||
}
|
||
|
||
alias talk {
|
||
if ([$1]==[-b]) {@ _oink = gz.autotalkfg} else {@ _oink = 1}
|
||
if ([$0]) {
|
||
for (@ idx = 1, (win = winitem($idx)) && !done, @ idx++) {
|
||
if (win) {
|
||
if (word(4 $win)==[$0]) {
|
||
gecho You already have a query to $0
|
||
@ borky = 1
|
||
}
|
||
} else {@ done = 1}
|
||
}
|
||
if (!borky) {
|
||
gecho ${gc.msginfo} Creating chat window with${cl} ${gc.msgfrom} $0${cl}
|
||
//^window create nicklist 0 query $0
|
||
if (autotalklogging == [ON]) {
|
||
switch ($gz.drivetype($gz.logdir)) {
|
||
(hpfs) {@ _talk.file = strip(\\*?<>|\"\' $0) ## [.log]}
|
||
(*) {@ _talk.file = left(8 $strip(\\*?<>|\"\' $0)) ## [.log]}
|
||
}
|
||
//^window $_moo logfile $gz.logdir\/$_talk.file
|
||
xecho -target $0 $gemz Window Logfile is $gz.logdir\/$_talk.file
|
||
//^window $_moo log on
|
||
xecho -target $0 $gemz Window LOG is ON
|
||
}
|
||
}
|
||
} else {gecho Usage talk <nick>}
|
||
^assign -done;^assign -borky;^assign -_moo;^assign -_oink
|
||
}
|
||
|
||
alias addhilite {
|
||
if ([$0]) {
|
||
if ([$0]==[-n]) {
|
||
push hilitelist $1
|
||
gecho \$1\ added to the hilite list.
|
||
} else {
|
||
if (match($0 $hilitelist)) {
|
||
gecho a matching highlite string was found, to force
|
||
gecho a new highlight, use /addhilite -n <string>
|
||
} else {
|
||
push hilitelist $0
|
||
gecho \$0\ added to the hilite list.
|
||
}
|
||
}
|
||
} else {
|
||
gecho Usage: /addhilite <word/filter>
|
||
}
|
||
}
|
||
|
||
alias addignore /ignore $*
|
||
|
||
alias addnotify {
|
||
if ([$0]) {
|
||
notify $0
|
||
} else {gecho Usage: /addnotify <nick1>}
|
||
}
|
||
|
||
alias showignore {
|
||
/ignore
|
||
}
|
||
|
||
alias cnames {
|
||
if ([$0]) {
|
||
if (ischannel($0)) {
|
||
if (onchannel($N $0)) {
|
||
gtecho $0 $0: $_cnames($0)
|
||
} else {gecho You are not on $0}
|
||
} else {gecho $0 is not a valid channel;gecho Usage: /cnames [<#channel>]}
|
||
} else {
|
||
if (C) {
|
||
gecho $C: $_cnames($C)
|
||
} else {gecho You are not on any channels}
|
||
}
|
||
}
|
||
|
||
alias _cnames {
|
||
fe ($chanusers($0)) _cn.ch {
|
||
if (ischanop($_cn.ch $0)) {
|
||
@ _cn.no #= [ @$_cn.ch]
|
||
} else {
|
||
@ _cn.nv #= isvoice($_cn.ch $0) ? [ +$_cn.ch] : [ $_cn.ch]
|
||
}
|
||
}
|
||
@ function_return = [${gc.chops}$_cn.no${cl}${gc.lamers}$_cn.nv$_cn.nl${cl}]
|
||
purge _cn
|
||
}
|
||
|
||
alias creseti {/c -inst+mlk 40 resetting;/c +inst-mlk resetting}
|
||
alias creset {/c -nst+milk 40 resetting;/c +nst-milk resetting}
|
||
alias ctcpreply if ([$0]) {gecho ${gc.ctcpban}ctcp${cl}: ${gc.ctcp}$tolower($1) reply${cl} from ${gc.ctcpnk}$0${cl}: $2-}
|
||
alias ctcpreq if ([$0]) {gecho ${gc.ctcpban}ctcp${cl}: ${gc.ctcp}$tolower($2) request${cl} from ${gc.ctcpnk}$0${cl} ${gc.peren}\(${gc.ctcpnk}$userhost()${gc.peren}\)${cl} to ${gc.ctcpnk}$1${cl}}
|
||
alias cwait {wait -CMD #;wait -CMD $0-}
|
||
|
||
alias ctogg {
|
||
if (![$0]) {
|
||
foreach ch.flags _ch {
|
||
gecho Channel $decode($_ch)\ flags $ch.flags[$_ch]\
|
||
}
|
||
gecho Usage: /ctogg [#channel] flags
|
||
} else {
|
||
if (![$1]) {
|
||
if (ischannel($0)) {
|
||
@ _ch = [$%0]
|
||
gecho Channel $decode($_ch)\ flags $ch.flags[$_ch]\
|
||
} else {
|
||
if (C) {
|
||
ctogg $C $0
|
||
} else {
|
||
gecho No current channel in this window
|
||
gecho Usage: /ctogg [#channel] flags
|
||
}
|
||
}
|
||
} else {
|
||
@ _ch = ischannel($0) ? [$0] : [#$0]
|
||
@ _wasm = index(M $ch.flags[$%_ch]) >= 0
|
||
@ ch.flags[$%_ch] = _alter_flags($_valid_ctogg($1) $ch.flags[$%_ch])
|
||
if (!ch.flags[$%_ch]) {
|
||
//^assign -ch.flags[$%_ch]
|
||
gecho Channel $_ch\ removed
|
||
if (_wasm) {
|
||
_recache_channels $_ch
|
||
}
|
||
} else {
|
||
gecho New flags for $_ch\ are '$ch.flags[$%_ch]'
|
||
if (_wasm != (index(M $ch.flags[$%_ch]) >= 0)) {
|
||
_recache_channels $_ch
|
||
}
|
||
}
|
||
}
|
||
}
|
||
//^assign -_ch
|
||
}
|
||
|
||
# cached /who
|
||
alias cwho {
|
||
if ([$0] && onchannel($N $0)) {
|
||
fe ($chanusers($0)) _n {
|
||
gecho ${ischanop($_n $0) ? [@] : isvoice($_n $0) ? [+] : [ ]}$[9]_n [$[8]nickdata($0 $_n 2)\] '$nick($_n)->host'
|
||
}
|
||
//^assign -_n
|
||
} else {
|
||
if ([$0]) {
|
||
gecho You are not on channel $0
|
||
} else {
|
||
if (C) {
|
||
cwho $C
|
||
} else {
|
||
gecho You aren't on any channel in this window
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
# cached banlist
|
||
alias csb {
|
||
if ([$0] && onchannel($N $0)) {
|
||
@ _idx = 0
|
||
@ _idx2 = 0
|
||
fe ($chanmode($0 1)) _n {
|
||
@ _idx++
|
||
gecho [$[2]_idx\] '$_n' $tdiff(${time() - word(${_idx2 * 3 + 2} $chanmode($0 2))}) old
|
||
gecho ${_idx2*3}
|
||
@ _idx2++
|
||
}
|
||
if ([$_idx]==[0]) {gecho There Are No Bans in $0}
|
||
//^assign -_n
|
||
//^assign -_idx
|
||
//^assign -_idx2
|
||
} else {
|
||
if ([$0]) {
|
||
gecho You are not on channel $0
|
||
} else {
|
||
if (C) {
|
||
csb $C
|
||
} else {
|
||
gecho You are on any channel in this window
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
#csc written by mikh, enhanced by gemini
|
||
alias csc {
|
||
if ([$0] && onchannel($N $0)) {
|
||
@ _co.t = #chanusers($C)_co.u
|
||
fe ($gz.chanops($0)) _co.tn {@ _co.co #= _co.co ? [ @$_co.tn] : [@$_co.tn]}
|
||
fe ($gz.voices($0)) _co.tn {@ _co.v #= _co.v ? [ +$_co.tn] : [+$_co.tn]}
|
||
@ _co.l = gz.lamers($0)
|
||
gtbecho $0 ${gc.cscborder}<7D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀ
|
||
gtbecho $0 ${gc.cscborder}<7D>${gc.topicchan}$[10]0${cl} ${gc.cscborder}<7D>${cl} ${gc.chops}ChanOps${cl}: \$[-3]#_co.co\ ${gc.cscborder}<7D>${cl} ${gc.lamers}Voiced${cl}: \$[-3]#_co.v\ ${gc.cscborder}<7D>${cl} ${gc.lamers}Normal${cl}: \$[-3]#_co.l\ ${gc.cscborder}<7D>${cl} Total: \$[-3]_co.t\ ${gc.cscborder}<7D>
|
||
gtbecho $0 ${gc.cscborder}<7D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ĵ
|
||
if (_co.co) {
|
||
fe ($_co.co) _co.1 _co.2 _co.3 _co.4 _co.5 _co.6 {
|
||
gtbecho $0 ${gc.cscborder}<7D> ${gc.chops}$[10]_co.1 $[10]_co.2 $[10]_co.3 $[10]_co.4 $[10]_co.5 $[10]_co.6 ${gc.cscborder}<7D>
|
||
}
|
||
}
|
||
if (_co.v || _co.l) {
|
||
fe ($_co.v $_co.l) _co.1 _co.2 _co.3 _co.4 _co.5 _co.6 {
|
||
gtbecho $0 ${gc.cscborder}<7D> ${gc.lamers}$[10]_co.1 $[10]_co.2 $[10]_co.3 $[10]_co.4 $[10]_co.5 $[10]_co.6 ${gc.cscborder}<7D>
|
||
}
|
||
}
|
||
gtbecho $0 ${gc.cscborder}<7D><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
|
||
purge _co
|
||
} else {
|
||
if ([$0]) {
|
||
gecho You are not on channel $0
|
||
} else {
|
||
if (C) {
|
||
csc $C
|
||
} else {
|
||
gecho No current channel in this window
|
||
}
|
||
}
|
||
}
|
||
purge _co
|
||
}
|
||
|
||
################################
|
||
# GemZ easy find Api functions #
|
||
################################
|
||
|
||
|
||
|
||
alias gz.bkgd {
|
||
switch ($_bkgd) {
|
||
(-) {@ _bkgd = [\\]}
|
||
(\\) {@ _bkgd = [|]}
|
||
(|) {@ _bkgd = [/]}
|
||
(/) {@ _bkgd = [-]}
|
||
(*) {@ _bkgd = [-]}
|
||
}
|
||
^set status_notify [$_bkgd][%F]
|
||
}
|
||
|
||
alias gz.bytestomegs {
|
||
^set float on
|
||
@ _xm.m = [$0] / 1048576
|
||
^set float off
|
||
@ function_return = mid(0 ${index(. $_xm.m) + 3} $_xm.m)
|
||
purge _xm
|
||
}
|
||
|
||
alias gz.chanops {
|
||
fe ($chanusers($0)) _h.o {
|
||
if (ischanop($_h.o $0)) {@ _h.r #= _h.r ? [ $_h.o] : _h.o}
|
||
}
|
||
@ function_return = _h.r
|
||
purge _h
|
||
}
|
||
|
||
alias chanops {@ function_return = gz.chanops($0)}
|
||
|
||
alias gz.chatstat {
|
||
# Input: <nick>
|
||
# return 0 if no chat
|
||
# rerurn 1 if chat is waiting
|
||
# return 2 if chat is active
|
||
# return 3 if chat is offered
|
||
@ function_return = 0
|
||
for (@ _d.i = 0, (_d.c = dccitem($_d.i)), @ _d.i++) {
|
||
if ((word(0 $_d.c) == [CHAT]) && (word(1 $_d.c) == [$0])) {
|
||
if (word(2 $_d.c) == [Active]) {@ function_return = 2
|
||
} else if (word(2 $_d.c) == [Offered]) {@ function_return = 3
|
||
} else {@ function_return = 1}
|
||
//break
|
||
}
|
||
}
|
||
purge _d
|
||
}
|
||
|
||
alias gz.chatwinstat {
|
||
# Input: <nick>
|
||
# return 0 if there isn't a window (regardless of dcc status)
|
||
# return 1 if there is a window (regardless of dcc status)
|
||
@ function_return = 0
|
||
for (@ _c.i = 1, (_c.w = winitem($_c.i)), @ _c.i++) {
|
||
if (_c.w) {
|
||
if (word(1 $_c.w) == [=$0_Queried]) {
|
||
@ function_return = 1
|
||
//break
|
||
}
|
||
}
|
||
}
|
||
purge _c
|
||
}
|
||
|
||
alias gz.rows {@ function_return = gz.dimension(row $*)}
|
||
alias gz.cols {@ function_return = gz.dimension(col $*)}
|
||
alias gz.dimension {
|
||
switch ($0) {
|
||
(col) {@ _cl.t = 8}
|
||
(row) {@ _cl.t = 9}
|
||
}
|
||
switch ($2) {
|
||
(r) {@ _cl.mw = 0}
|
||
(n) {@ _cl.mw = 1}
|
||
(c) {@ _cl.mw = 3}
|
||
(q) {@ _cl.mw = 4}
|
||
(*) {@ _cl.mw = 0}
|
||
}
|
||
@ function_return = 0
|
||
for (@ _cl.i = 1, _cl.w = winitem($_cl.i), @ _cl.i++) {
|
||
if (word($_cl.mw $_cl.w) == [$1]) {
|
||
@ function_return = word($_cl.t $_cl.w)
|
||
//break
|
||
}
|
||
}
|
||
purge _cl
|
||
}
|
||
|
||
alias gz.exdcc {//dcc $0 $1 "$decode($2)"}
|
||
alias gz.finuh {@ function_return = is_ip($0@$1) ? [$0] ## [@] ## [$1] : fix.umask($0 $1)}
|
||
|
||
alias gz.finline {
|
||
@ _w.i = [..................................................................]
|
||
@ _w.0 = [$0]
|
||
@ _w.1 = strip( $1)
|
||
@ _w.2 = strip( $2)
|
||
@ _w.s = _w.0 - (@_w.1 + @_w.2)
|
||
if (_w.s < 1) {@ _w.s = 0}
|
||
@ function_return = [$1] ## left($_w.s $_w.i) ## [$2]
|
||
purge _w
|
||
}
|
||
|
||
alias gz.fixbytes {
|
||
^set float on
|
||
if ([$0] < 1000) {@ function_return = [$0] ## [b]
|
||
} else if ([$0] < 10240) {@ function_return = left(3 ${[$0] / 1024}) ## [k]
|
||
} else if ([$0] < 102400) {@ function_return = left(2 ${[$0] / 1024}) ## [k]
|
||
} else if ([$0] < 1022976) {@ function_return = left(3 ${[$0] / 1024}) ## [k]
|
||
} else if ([$0] < 10485761) {@ function_return = left(3 ${[$0] / 1048576}) ##[M]
|
||
} else if ([$0] < 104857600) {@ function_return = left(2 ${[$0] / 1048576}) ##[M]
|
||
} else {@ function_return = left(3 ${[$0] / 1048576}) ##[M]}
|
||
^set float off
|
||
}
|
||
|
||
|
||
alias gz.fixnum {
|
||
if (left(1 $0) == [-]) {@ _fn.neg = 1}
|
||
fec ($0) _fn.rc {@ _fn.r = _fn.rc ## _fn.r}
|
||
@ _fn.r = strip(- $_fn.r)
|
||
fec ($_fn.r) _fn.sc {
|
||
if (_fn.c == 3) {@ _fn.c = 0;@ _fn.scr = _fn.sc ## [,] ## _fn.scr} else {@ _fn.scr = _fn.sc ## _fn.scr}
|
||
@ _fn.c++
|
||
}
|
||
if (_fn.neg) {@ _fn.scr = [-] ## _fn.scr}
|
||
@ function_return = _fn.scr
|
||
purge _fn
|
||
}
|
||
|
||
alias gz.fixpath {
|
||
fec ($*) _fp.c {if ([$_fp.c]==[\\]) {if (_fp.r) {@ _fp.r #= [/]} else {@ _fp.r = [/]}} else {if (_fp.r) {@ _fp.r #= _fp.c} else {@ _fp.r = _fp.c}}}
|
||
@ function_return = _fp.r
|
||
purge _fp
|
||
}
|
||
|
||
alias gz.getdate {
|
||
@ _d = stime($time()))
|
||
@ function_return = [$gz.getmonth($word(1 $_d))]##[/]##[$word(2 $_d)]##[/]##[$right(2 $word(4 $_d))]
|
||
^assign -_d
|
||
}
|
||
|
||
alias gz.getmonth {
|
||
switch ($0) {
|
||
(Jan) {@ _m = 1}
|
||
(Feb) {@ _m = 2}
|
||
(Mar) {@ _m = 3}
|
||
(Apr) {@ _m = 4}
|
||
(May) {@ _m = 5}
|
||
(Jun) {@ _m = 6}
|
||
(Jul) {@ _m = 7}
|
||
(Aug) {@ _m = 8}
|
||
(Sep) {@ _m = 9}
|
||
(Oct) {@ _m = 10}
|
||
(Nov) {@ _m = 11}
|
||
(Dec) {@ _m = 12}
|
||
}
|
||
@ function_return = _m
|
||
^assign -_m
|
||
}
|
||
|
||
alias gz.hasnicklist {
|
||
# takes in $T for window in question
|
||
if (chanwindow($0)) {
|
||
for (@ _is.i = 1, _is.w = winitem($_is.i), @ _is.i++) {
|
||
if (word(0 $_is.w) == chanwindow($0)) {
|
||
@ function_return = index(N $word(16 $_is.w)) >= 0 ? 1 : 0
|
||
//break
|
||
}}}
|
||
purge _is
|
||
}
|
||
|
||
alias gz.isoper {@ function_return = O == status_oper ? 1 : gz.localoper}
|
||
|
||
alias gz.lamers {
|
||
fe ($chanusers($0)) _h.o {
|
||
if (!isvoice($_h.o $0) && !ischanop($_h.o $0)) {@ _h.r #= _h.r ? [ $_h.o] : _h.o}
|
||
}
|
||
@ function_return = _h.r
|
||
purge _h
|
||
}
|
||
|
||
alias gz.nban {
|
||
@ _nb.u = [$strip(~ $mid(0 $index(@ $1) $1))]
|
||
@ _nb.u = [$right(8 $_nb.u)]
|
||
@ _nb.h = [$strip(@ $mid($index(@ $1) $@1 $1))]
|
||
if (is_ip($1)) {
|
||
@ function_return = [*!*]## _nb.u ## [@] ## [$mid(0 $rindex(. $_nb.h) $_nb.h).*]
|
||
} else {
|
||
if (index(. $1) != rindex(. $1)) {@ function_return = [*!*$fix.umask($_nb.u $_nb.h)]} else {@ FUNCTION_RETURN = [*!*] ## _nb.u ## [@] ## _nb.h}
|
||
}
|
||
purge _nb
|
||
}
|
||
|
||
alias gz.playsnd {if (gz.sounds) {playfile $(snd.$0)}}
|
||
alias gz.randnick {
|
||
@ _r.c = [abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ_^\\\{\}\[\]`|0123456789-]
|
||
@ _r.n = mid($rand(62) 1 $_r.c)
|
||
for (@ _r.l = 1, _r.l < 9, @ _r.l++) {
|
||
@ _r.n = _r.n ## mid($rand(62) 1 $_r.c)
|
||
}
|
||
@ function_return = _r.n
|
||
purge _r
|
||
}
|
||
alias gz.reverse {
|
||
fec ($*) _r.c {@ _r.r = _r.c ## _r.r}
|
||
@ function_return = _r.r
|
||
purge _r
|
||
}
|
||
|
||
alias gz.safechan {
|
||
if (index(# $0) == [0]) {@ _sf.r = [$0]
|
||
} else if (index(# $0) == [1] && ( (index(+ $0) == [0]) || (index(@ $0) == [0])) ) {
|
||
@ _sf.r = mid(1 9999 $0)
|
||
} else { @ _sf.r = [$0] }
|
||
@ function_return = _sf.r
|
||
purge _sf.r
|
||
}
|
||
|
||
|
||
alias gz.servergroups {
|
||
for (@ _sg.i = 0, servername($_sg.i), @_sg.i++) {
|
||
if (!match($servergroup($_sg.i) $_sg.r)) {
|
||
@ _sg.r #= _sg.r ? [ ] ## servergroup($_sg.i) : servergroup($_sg.i)
|
||
}
|
||
}
|
||
@ function_return = _sg.r
|
||
purge _sg
|
||
}
|
||
|
||
alias gz.striplastslash {@ function_return = right(1 $*)==[/] ? left(${gz.strlen($*) - 1} $*) : [$*]}
|
||
alias gz.strlen {@ _t = [$*];@ function_return = @_t;^assign -_t}
|
||
alias gz.stripfw {
|
||
if ([$0] == [$1]) {
|
||
@ _wr.r = [$2-]
|
||
} else {
|
||
@ _wr.r = [$1-]
|
||
@ _wr.n = 0
|
||
fe ($1-) _wr.d {
|
||
@ _wr.n++
|
||
if (_wr.d == [$0]) {
|
||
@ _wr.r = ref(1-${_wr.n - 1} $1-) ## [ ] ## ref(${_wr.n + 1}\-1000 $1-)
|
||
//break
|
||
}
|
||
}
|
||
}
|
||
@ function_return = _wr.r
|
||
purge _wr
|
||
}
|
||
|
||
|
||
alias gz.subaway {
|
||
@ away = 1
|
||
if ([$1]) {@ away.reason = [$1-]} else {@ away.reason = [$away[$rand($numaway)]]}
|
||
//away -all $away.reason [Log:$logging] $gemz.str
|
||
gecho Setting you away. Message logging is \$logging\
|
||
switch ($0) {
|
||
(-q) {gecho Quiet Away Reason: $away.reason}
|
||
(-c) {if (C) {/me $str.away \($away.reason\) [Log:$logging] $gemz.str}}
|
||
(-n) {
|
||
if (mychannels()) {
|
||
/tzmme $str.away \($away.reason\) [Log:$logging] $gemz.str
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
alias gz.testoper {
|
||
#Idea/inspiration by Blackjac. Implementation GemZ dependent.
|
||
_gz.OperTestAddNick $0 $1
|
||
userhost $0 -cmd if ([$1] == [+]) {
|
||
@ gt.tn = _gz.OperTestDoNick($0)
|
||
if (gt.tn) {
|
||
gtecho $gt.tn ${gc.opernick}$0${cl} ${gc.peren}\(${gc.operuh}$3@$4${gc.peren}\)${cl} is a megamomo ( IRCop ).
|
||
} else {
|
||
gecho ${gc.opernick}$0${cl} ${gc.peren}\(${gc.operuh}$3@$4${gc.peren}\)${cl} is a megamomo ( IRCop ).
|
||
}
|
||
} else {@ _gz.OperTestDoNick($0)}
|
||
^assign -gt.tn
|
||
}
|
||
|
||
alias gz.voices {
|
||
fe ($chanusers($0)) _h.o {
|
||
if (isvoice($_h.o $0) && !ischanop($_h.o $0)) {@ _h.r #= _h.r ? [ $_h.o] : _h.o}
|
||
}
|
||
@ function_return = _h.r
|
||
purge _h
|
||
}
|
||
|
||
alias quiet {
|
||
if ([$0]) {
|
||
if (ischanop($N $C)) {
|
||
//mode $C -v $0
|
||
}{gecho You are not a channel Operator}
|
||
}{gecho Usage: //quiet <nick>}
|
||
}
|
||
|
||
alias tlm {t $last.mesg}
|
||
alias tlsm {t $lastmsmg}
|
||
alias tlsn {t $lastsnot}
|
||
alias tln {t $last.noti}
|
||
|
||
|
||
##action plugin module support for GemZ 2.5
|
||
##Format for the plugin file must be one line per //menuitem using
|
||
## the following keyword format
|
||
##"TITLE" TYPE TEXT GOES HERE
|
||
## Type Keywords are: %ACT, %PUB, %KICK or %CMD
|
||
## Other Keywords are %nk (nick) %pnk (possesive nick)
|
||
## and %ch (current channel)
|
||
## Comment lines must begin with a pound (#)
|
||
##To create a new column in the //submenu, put %new as the second word
|
||
## followed by a Command keyword
|
||
##%kick must have %nk following it immediately.
|
||
##%cmd must be followed by a valid command... like /gimpkick
|
||
|
||
alias loadplug {
|
||
@ pluginsloaded = 1
|
||
if ([$0] && fexist($0)==[1]) {
|
||
# makepopup
|
||
//menuitem popup separator
|
||
//submenu popup custact "Custom Actions"
|
||
//submenu popup custkick "Custom Kicks"
|
||
//submenu popup custcmd "Custom Command"
|
||
@ _plugfile = open($0 R)
|
||
while (!eof($_plugfile)) {
|
||
@ _tmp.p = strip(; $read($_plugfile))
|
||
@ _tmp.p = [$^(^)_tmp.p]
|
||
if (left(1 $_tmp.p) == [#]) {
|
||
} else if (word(1 $_tmp.p) == [%new]) {
|
||
switch ($word(2 $_tmp.p)) {
|
||
(%cmd) {//menuitem custcmd -b "$word(0 $_tmp.p)" custout $stripw(%new $_tmp.p)}
|
||
(%kick) {//menuitem custkick -b "$word(0 $_tmp.p)" custout $stripw(%new $_tmp.p)}
|
||
(%act) {//menuitem custact -b "$word(0 $_tmp.p)" custout $stripw(%new $_tmp.p)}
|
||
(%pub) {//menuitem custact -b "$word(0 $_tmp.p)" custout $stripw(%new $_tmp.p)}
|
||
(*) {}
|
||
}
|
||
} else {
|
||
switch ($word(1 $_tmp.p)) {
|
||
(%cmd) {//menuitem custcmd "$word(0 $_tmp.p)" custout $_tmp.p}
|
||
(%kick) {//menuitem custkick "$word(0 $_tmp.p)" custout $_tmp.p}
|
||
(%act) {//menuitem custact "$word(0 $_tmp.p)" custout $_tmp.p}
|
||
(%pub) {//menuitem custact "$word(0 $_tmp.p)" custout $_tmp.p}
|
||
(*) {}
|
||
}
|
||
}
|
||
}
|
||
@ close($_plugfile)
|
||
^assign -_tmp.p;^assign -_plugfile
|
||
}{gecho No module specifed, or file does not exist}
|
||
}
|
||
|
||
alias custout {
|
||
@ _nick = [$strip(@+=\'\" $lastclickline(4))]
|
||
@ _chan = [$C]
|
||
@ _input = [$1-]
|
||
if ([$1]==[%act] || [$1]==[%pub] || [$1]==[%kick] || [$1]==[%cmd]) {
|
||
fe ($_input) _word {
|
||
if ([$_word]==[%act]) { @ _output = [$_output]##[/me]
|
||
} else if ([$_word]==[%pub]) { @ _output = [$_output]##[/say]
|
||
} else if ([$_word]==[%kick]) { @ _output = [$_output]##[/k]
|
||
} else if ([$_word]==[%cmd]) {@ _cmd = [true]
|
||
} else if ([$_word]==[%nk]) { @ _output = [$_output $_nick]
|
||
} else if ([$_word]==[%nk,]) { @ _output = [$_output $_nick\,]
|
||
} else if ([$_word]==[%nk.]) { @ _output = [$_output $_nick\.]
|
||
} else if ([$_word]==[%nk!]) { @ _output = [$_output $_nick\!]
|
||
} else if ([$_word]==[%pnk]) { @ _output = [$_output $_nick\'s]
|
||
} else if ([$_word]==[%ch]) { @ _output = [$_output $_chan]
|
||
} else if (_cmd) { @ _output = [$_output]##[$_word];^assign -_cmd
|
||
} else @ _output = [$_output $strip(; $_word)]
|
||
}
|
||
eval $_output
|
||
#gecho $_output
|
||
} else {
|
||
gecho $_input
|
||
gecho ERROR in plugin (2nd word not %act, %pub, %kick, %cmd)
|
||
}
|
||
^assign -_output;^assign -_chan;^assign -_input
|
||
}
|
||
|
||
alias saysend {
|
||
.send $0-
|
||
fe ($unparse($0)) _s {
|
||
xecho -target $_s ${gc.pubbrac}<${gc.spub}$N${gc.pubbrac}>${cl} $1-
|
||
}
|
||
^assign -_s
|
||
}
|
||
|
||
alias .send quote PRIVMSG $0 :$cntl2mirc(f0 $1-)
|
||
|
||
# Finish up
|
||
|
||
if (fexist($EXEDIR/menu.sav) != -1)
|
||
{
|
||
//load $EXEDIR/menu.sav
|
||
}
|
||
|
||
^bind rclick parse_command rccheck
|
||
^bind nicklistrclick parse_command rccheck
|
||
^bind ldblclick parse_command ldccheck
|
||
^bind nicklistldblclick parse_command ldccheck
|
||
^bind statusrclick parse_command if (C) {chanmenu $C} else {if (T) {targetmenu $strip(= $T)}}
|
||
|
||
^makemenu
|
||
|