/**
* @brief: Edje signal callback for the clicking or selecting of the new note option.
* This calls up a new note.
*/
void
cc_newnote(void *data, Evas_Object * obj, const char *emission,
const char *source)
{
new_note();
return;
}
void note_attach( CHAR_DATA *ch, int type )
{
NOTE_DATA *pnote;
if ( ch->pnote != NULL )
return;
pnote = new_note();
pnote->next = NULL;
pnote->sender = (IS_NPC(ch)) ? palloc_string(ch->short_descr) : palloc_string(ch->true_name);
pnote->date = palloc_string( "" );
pnote->to_list = palloc_string( "" );
pnote->subject = palloc_string( "" );
pnote->text = palloc_string( "" );
pnote->type = type;
ch->pnote = pnote;
return;
}
void note_attach( CHAR_DATA *ch, int type )
{
NOTE_DATA *pnote;
if ( ch->pnote != NULL )
return;
pnote = new_note();
pnote->next = NULL;
pnote->sender = str_dup( ch->name );
pnote->date = str_dup( "" );
pnote->to_list = str_dup( "" );
pnote->subject = str_dup( "" );
pnote->text = str_dup( "" );
pnote->type = type;
ch->pnote = pnote;
return;
}
void note_attach ( Creature *ch, int type )
{
NOTE_DATA *pnote;
if ( ch->pnote != NULL )
{ return; }
pnote = new_note();
pnote->next = NULL;
pnote->sender = assign_string ( ch->name );
pnote->date = assign_string ( "" );
pnote->to_list = assign_string ( "" );
pnote->subject = assign_string ( "" );
pnote->text = assign_string ( "" );
pnote->type = type;
ch->pnote = pnote;
return;
}
void make_note (const char* board_name, const char *sender, const char *to, const char *subject, const int expire_days, const char *text)
{
int board_index = board_lookup (board_name);
BOARD_DATA *board;
NOTE_DATA *note;
char *strtime;
if (board_index == BOARD_NOTFOUND)
{
bug ("make_note: board not found",0);
return;
}
if (strlen2(text) > MAX_NOTE_TEXT)
{
bug ("make_note: text too long (%d bytes)", strlen2(text));
return;
}
board = &boards [board_index];
note = new_note(); /* allocate new note */
note->sender = str_dup (sender);
note->to_list = str_dup(to);
note->subject = str_dup (subject);
note->expire = current_time + expire_days * 60 * 60 * 24;
note->text = str_dup (text);
/* convert to ascii. ctime returns a string which last character is \n, so remove that */
strtime = ctime (¤t_time);
strtime[strlen(strtime)-1] = '\0';
note->date = str_dup (strtime);
finish_note (board, note);
}
/**
* @param argc: Number of command line arguments supplied.
* @param argv: Char* array containing the command line arguments supplied.
* @return: To the system, normally 0.
* @brief: The first function once enotes is called.
*/
int
main(int argc, char *argv[])
{
int note_count;
/* IPC Check */
ecore_ipc_init();
dml("IPC Initiated Successfully", 1);
/* loading will increment this if there are notes if not we may need to
* create a blank one */
note_count = 0;
if ((ecore_config_init("enotes")) == ECORE_CONFIG_ERR_FAIL) {
ecore_ipc_shutdown();
return (-1);
}
ecore_app_args_set(argc, (const char **) argv);
ecore_config_app_describe("E-Notes - Sticky Notes for Enlightenment\n\
Copyright (c) Thomas Fletcher\n\
Usage: enotes [options]");
/* Read the Usage and Configurations */
main_config = mainconfig_new();
if (read_configuration(main_config) != ECORE_CONFIG_PARSE_CONTINUE) {
ecore_config_shutdown();
ecore_ipc_shutdown();
ecore_shutdown();
mainconfig_free(main_config);
return (-1);
}
dml("Successfully Read Configurations and Usage", 1);
process_note_storage_locations();
if (find_server() != 0) {
if (remotecmd != NULL)
send_to_server(remotecmd);
else
send_to_server("DEFNOTE");
} else {
dml("Server wasn't found.. Creating one", 1);
/* Setup Server */
setup_server();
/* Initialise the E-Libs */
ecore_init();
ecore_x_init(NULL);
ecore_app_args_set(argc, (const char **) argv);
if (!ecore_evas_init()) {
mainconfig_free(main_config);
return -1;
}
ewl_init(&argc, argv);
edje_init();
dml("Efl Successfully Initiated", 1);
autoload();
/* create autosave timer */
update_autosave();
if (remotecmd != NULL)
handle_ipc_message(remotecmd);
/* Begin the Control Centre */
if (main_config->controlcentre == 1) {
setup_cc();
dml("Control Centre Setup", 1);
} else {
dml("No Control Centre - Displaying Notice", 1);
if (get_note_count() == 0)
new_note();
}
if (main_config->welcome == 1) {
open_welcome();
}
/* Begin the main loop */
dml("Starting Main Loop", 1);
ecore_main_loop_begin();
dml("Main Loop Ended", 1);
/* Save Controlcentre Settings */
set_cc_pos();
autosave();
if (autosave_timer)
ecore_timer_del(autosave_timer);
/* Save and Free the Configuration */
ecore_config_save();
dml("Configuration Saved", 1);
mainconfig_free(main_config);
dml("Configuration Structure Free'd", 1);
/* Shutdown the E-Libs */
edje_shutdown();
ecore_evas_shutdown();
ecore_x_shutdown();
ecore_shutdown();
dml("Efl Shutdown", 1);
}
/* End IPC */
ecore_ipc_shutdown();
dml("IPC Shutdown", 1);
dml("Leaving.", 1);
return (0);
}
void InstrumentFunctionArpeggio::processNote( NotePlayHandle * _n )
{
const int base_note_key = _n->key();
if( _n->isTopNote() == false ||
!m_arpEnabledModel.value() ||
( _n->isReleased() && _n->releaseFramesDone() >= _n->actualReleaseFramesToDo() ) )
{
return;
}
const int selected_arp = m_arpModel.value();
ConstNotePlayHandleList cnphv = NotePlayHandle::nphsOfInstrumentTrack(
_n->instrumentTrack() );
if( m_arpModeModel.value() != FreeMode && cnphv.size() == 0 )
{
// maybe we're playing only a preset-preview-note?
cnphv = PresetPreviewPlayHandle::nphsOfInstrumentTrack( _n->instrumentTrack() );
if( cnphv.size() == 0 )
{
// still nothing found here, so lets return
//return;
cnphv.push_back( _n );
}
}
const InstrumentFunctionNoteStacking::ChordTable & chord_table = InstrumentFunctionNoteStacking::ChordTable::getInstance();
const int cur_chord_size = chord_table[selected_arp].size();
const int range = (int)( cur_chord_size * m_arpRangeModel.value() );
const int total_range = range * cnphv.size();
// number of frames that every note should be played
const f_cnt_t arp_frames = (f_cnt_t)( m_arpTimeModel.value() / 1000.0f *
engine::mixer()->processingSampleRate() );
const f_cnt_t gated_frames = (f_cnt_t)( m_arpGateModel.value() *
arp_frames / 100.0f );
// used for calculating remaining frames for arp-note, we have to add
// arp_frames-1, otherwise the first arp-note will not be setup
// correctly... -> arp_frames frames silence at the start of every note!
int cur_frame = ( ( m_arpModeModel.value() != FreeMode ) ?
cnphv.first()->totalFramesPlayed() :
_n->totalFramesPlayed() ) + arp_frames - 1;
// used for loop
f_cnt_t frames_processed = 0;
while( frames_processed < engine::mixer()->framesPerPeriod() )
{
const f_cnt_t remaining_frames_for_cur_arp = arp_frames -
( cur_frame % arp_frames );
// does current arp-note fill whole audio-buffer?
if( remaining_frames_for_cur_arp >
engine::mixer()->framesPerPeriod() )
{
// then we don't have to do something!
break;
}
frames_processed += remaining_frames_for_cur_arp;
// init with zero
int cur_arp_idx = 0;
// in sorted mode: is it our turn or do we have to be quiet for
// now?
if( m_arpModeModel.value() == SortMode &&
( ( cur_frame / arp_frames ) % total_range ) /
range != (f_cnt_t) _n->index() )
{
// update counters
frames_processed += arp_frames;
cur_frame += arp_frames;
continue;
}
const int dir = m_arpDirectionModel.value();
// process according to arpeggio-direction...
if( dir == ArpDirUp )
{
cur_arp_idx = ( cur_frame / arp_frames ) % range;
}
else if( dir == ArpDirDown )
{
cur_arp_idx = range - ( cur_frame / arp_frames ) %
range - 1;
}
else if( dir == ArpDirUpAndDown && range > 1 )
{
// imagine, we had to play the arp once up and then
// once down -> makes 2 * range possible notes...
// because we don't play the lower and upper notes
// twice, we have to subtract 2
cur_arp_idx = ( cur_frame / arp_frames ) %
( range * 2 - 2 );
// if greater than range, we have to play down...
// looks like the code for arp_dir==DOWN... :)
if( cur_arp_idx >= range )
{
cur_arp_idx = range - cur_arp_idx %
( range - 1 ) - 1;
}
}
else if( dir == ArpDirRandom )
{
// just pick a random chord-index
cur_arp_idx = (int)( range * ( (float) rand() /
(float) RAND_MAX ) );
}
// now calculate final key for our arp-note
const int sub_note_key = base_note_key + (cur_arp_idx /
cur_chord_size ) *
KeysPerOctave +
chord_table[selected_arp][cur_arp_idx % cur_chord_size];
// range-checking
if( sub_note_key >= NumKeys ||
sub_note_key < 0 ||
engine::mixer()->criticalXRuns() )
{
continue;
}
float vol_level = 1.0f;
if( _n->isReleased() )
{
vol_level = _n->volumeLevel( cur_frame + gated_frames );
}
// create new arp-note
note new_note( MidiTime( 0 ), MidiTime( 0 ),
sub_note_key,
(volume_t)
qRound( _n->getVolume() * vol_level ),
_n->getPanning(), _n->detuning() );
// create sub-note-play-handle, only ptr to note is different
// and is_arp_note=true
new NotePlayHandle( _n->instrumentTrack(),
( ( m_arpModeModel.value() != FreeMode ) ?
cnphv.first()->offset() :
_n->offset() ) +
frames_processed,
gated_frames,
new_note,
_n, true );
// update counters
frames_processed += arp_frames;
cur_frame += arp_frames;
}
// make sure, note is handled as arp-base-note, even if we didn't add a
// sub-note so far
if( m_arpModeModel.value() != FreeMode )
{
_n->setPartOfArpeggio( true );
}
}
/* Start writing a note */
static void do_nwrite (CHAR_DATA *ch, char *argument)
{
char *strtime;
char buf[200];
if (IS_NPC(ch)) /* NPC cannot post notes */
return;
//if ((get_age(ch) - 17) < 2)
//{
// send_to_char("Newbies cannot write notes.\n\r",ch);
// return;
// }
if (has_timer(ch)) return;
if (IS_SET(ch->act, PLR_SILENCE) )
{
send_to_char("You are not allowed to write notes.\n\r",ch);
return;
}
if (ch->pcdata->board == NULL) {
send_to_char("You're not on a board.\n\r", ch );
return;}
if (get_trust(ch) < ch->pcdata->board->write_level)
{
send_to_char ("You cannot post notes on this board.\n\r",ch);
return;
}
if (ch->position != POS_STANDING)
{
send_to_char("You can only write notes while standing.\n\r", ch);
return;
}
/* continue previous note, if any text was written*/
if (ch->pcdata->in_progress && (!ch->pcdata->in_progress->text))
{
send_to_char ("Note in progress cancelled because you did not manage to write any text \n\r"
"before losing link.\n\r\n\r",ch);
free_note (ch->pcdata->in_progress);
ch->pcdata->in_progress = NULL;
}
if (!ch->pcdata->in_progress)
{
ch->pcdata->in_progress = new_note();
ch->pcdata->in_progress->sender = str_dup (ch->pcdata->switchname);
/* convert to ascii. ctime returns a string which last character is \n, so remove that */
strtime = ctime (¤t_time);
strtime[strlen(strtime)-1] = '\0';
ch->pcdata->in_progress->date = str_dup (strtime);
}
SET_BIT(ch->extra, EXTRA_AFK);
if (ch->master) stop_follower(ch, FALSE);
act (BOLD GREEN "$n starts writing a note." NO_COLOR , ch, NULL, NULL, TO_ROOM);
/* Begin writing the note ! */
xprintf (buf, "You are now %s a new note on the " BOLD "%s" NO_COLOR " board.\n\r"
"If you are using tintin, type #verbose to turn off alias expansion!\n\r\n\r",
ch->pcdata->in_progress->text ? "continuing" : "posting",
ch->pcdata->board->short_name);
send_to_char (buf,ch);
xprintf (buf, BOLD YELLOW "From" NO_COLOR ": %s\n\r\n\r", ch->pcdata->switchname);
send_to_char (buf,ch);
if (!ch->pcdata->in_progress->text) /* Are we continuing an old note or not? */
{
switch (ch->pcdata->board->force_type)
{
case DEF_NORMAL:
xprintf (buf, "If you press Return, default recipient \"" BOLD "%s" NO_COLOR "\" will be chosen.\n\r",
ch->pcdata->board->names);
break;
case DEF_INCLUDE:
xprintf (buf, "The recipient list MUST include \"" BOLD "%s" NO_COLOR "\". If not, it will be added automatically.\n\r",
ch->pcdata->board->names);
break;
case DEF_EXCLUDE:
xprintf (buf, "The recipient of this note must NOT include: \"" BOLD "%s" NO_COLOR "\".",
ch->pcdata->board->names);
break;
}
send_to_char (buf,ch);
send_to_char ("\n\r" BOLD YELLOW "To" NO_COLOR ": ",ch);
ch->desc->connected = CON_NOTE_TO;
/* nanny takes over from here */
}
else /* we are continuing, print out all the fields and the note so far*/
{
xprintf (buf, BOLD YELLOW "To" NO_COLOR ": %s\n\r"
BOLD YELLOW "Expires" NO_COLOR ": %s\n\r"
BOLD YELLOW "Subject" NO_COLOR ": %s\n\r",
ch->pcdata->in_progress->to_list,
ctime(&ch->pcdata->in_progress->expire),
ch->pcdata->in_progress->subject);
send_to_char (buf,ch);
send_to_char (BOLD GREEN "Your note so far:\n\r" NO_COLOR,ch);
if (ch->pcdata->in_progress != NULL)
send_to_char (ch->pcdata->in_progress->text,ch);
send_to_char ("\n\rEnter text. Type " BOLD "~" NO_COLOR " or " BOLD "END" NO_COLOR " on an empty line to end note.\n\r"
"=======================================================\n\r",ch);
ch->desc->connected = CON_NOTE_TEXT;
}
}
