/*
 * Copyright (C) Volition, Inc. 1999.  All rights reserved.
 *
 * All source code herein is the property of Volition, Inc. You may not sell 
 * or otherwise commercially exploit the source or things you created based on the 
 * source.
 *
*/ 


#include <string.h>
#include <setjmp.h>

#include "controlconfig/controlsconfig.h"
#include "debugconsole/console.h"
#include "gamehelp/contexthelp.h"
#include "gamesequence/gamesequence.h"
#include "globalincs/alphacolors.h"
#include "globalincs/systemvars.h"
#include "graphics/2d.h"
#include "localization/localize.h"
#include "menuui/barracks.h"
#include "menuui/mainhallmenu.h"
#include "menuui/readyroom.h"
#include "menuui/techmenu.h"
#include "mission/missionhotkey.h"
#include "missionui/missionbrief.h"
#include "missionui/missioncmdbrief.h"
#include "missionui/missiondebrief.h"
#include "missionui/missionshipchoice.h"
#include "missionui/missionweaponchoice.h"
#include "network/multiui.h"
#include "parse/parselo.h"



////////////////////////////////////////////////////////////////////
// private function prototypes / structs
////////////////////////////////////////////////////////////////////
void parse_helptbl(const char *filename);
void help_overlay_blit(int overlay_id, int resolution_index);
void help_overlay_init();


typedef struct {
	int x_begin, y_begin, x_end, y_end;
} help_line;

typedef struct {
	SCP_vector<vec3d> vtx;
	int vtxcount;
} help_pline;

typedef struct {
	int x_coord, y_coord;
	char* string;
} help_text;

typedef struct {
	int x_coord, y_coord;
} help_left_bracket;

typedef struct {
	int x_coord, y_coord;
} help_right_bracket;

typedef struct {
	char name[HELP_MAX_NAME_LENGTH];
	int num_resolutions;
	SCP_vector<int>	fontlist;
	SCP_vector<SCP_vector<help_pline> >			plinelist;
	SCP_vector<SCP_vector<help_text> >			textlist;
	SCP_vector<SCP_vector<help_left_bracket> >	lbracketlist;
	SCP_vector<SCP_vector<help_right_bracket> >	rbracketlist;
	int plinecount;
	int textcount;
	int lbracketcount;
	int rbracketcount;
} help_overlay;

////////////////////////////////////////////////////////////////////
// Game-wide globals
////////////////////////////////////////////////////////////////////
shader Grey_shader;

////////////////////////////////////////////////////////////////////
// Module globals
////////////////////////////////////////////////////////////////////
static int help_left_bracket_bitmap;
static int help_right_bracket_bitmap;
static help_overlay help_overlaylist[MAX_HELP_OVERLAYS];
int num_help_overlays;

static int current_helpid = -1;		// the currently active overlay_id, only really used for the debug console funxions
static int current_resolution = -1;
int Help_overlay_flags;
static int Source_game_state;			// state from where F1 was pressed

////////////////////////////////////////////////////////////////////
// Public Functions
////////////////////////////////////////////////////////////////////


int help_overlay_get_index(const char* overlay_name)
{
	for (int i = 0; i < num_help_overlays; i++) {
		if (!stricmp(overlay_name, help_overlaylist[i].name)) {
			return i;
		}
	}

	return -1;
}

// query whether a help overlay is active (ie being displayed)
int help_overlay_active(int overlay_id)
{
	Assert(overlay_id < MAX_HELP_OVERLAYS);

	if (overlay_id < 0) {
		return 0;
	}

	return Help_overlay_flags & (1<<overlay_id);
}

// stop displaying a help overlay
void help_overlay_set_state(int overlay_id, int resolution_index, int state)
{
	Assert(overlay_id < MAX_HELP_OVERLAYS);

	if ( (overlay_id >= 0) && (overlay_id < num_help_overlays) &&
			(resolution_index >= 0) && (resolution_index < help_overlaylist[overlay_id].num_resolutions) ) {
		if ( state > 0 ) {
			Help_overlay_flags |= (1<<overlay_id);
			current_helpid = overlay_id;
			current_resolution = resolution_index;
		} else {
			Help_overlay_flags &= ~(1<<overlay_id);
			//current_helpid = -1;
		}
	}

}

// maybe blit a bitmap of a help overlay to the screen
void help_overlay_maybe_blit(int overlay_id, int resolution_index)
{
	Assert(overlay_id < MAX_HELP_OVERLAYS);

	if ( (overlay_id >= 0) && (Help_overlay_flags & (1<<overlay_id)) &&
			(resolution_index >= 0) && (resolution_index < help_overlaylist[overlay_id].num_resolutions) ) {
		context_help_grey_screen();
		help_overlay_blit(overlay_id, resolution_index);
	}
}

// reset the flags for the help overlays
void help_overlay_reset_all()
{
	Help_overlay_flags = 0;
}

// Set up Grey_shader, which is used game-wide to grey out background when using help overlays
void create_grey_shader()
{
	/*float tmp,c;

	tmp = 0.4f/3.0f;

	// The c matrix brightens everything a bit.
//	c = 0.125f;
	c = 0.110f;*/

	gr_create_shader( &Grey_shader, 34, 34, 34, 168 );
}

// called at game startup to init all help related data
void context_help_init() 
{
	create_grey_shader();
	help_overlay_reset_all();
	help_overlay_init();
}

void context_help_grey_screen()
{
	gr_set_shader(&Grey_shader);
	gr_shade(0,0,gr_screen.clip_width, gr_screen.clip_height, GR_RESIZE_NONE);
}

// launch_context_help() will switch to a context sensitive help state
void launch_context_help()
{
	int overlay_id = -1;
	int resolution_index = gr_screen.res;

	// look at the state the game was in when F1 was pressed
	Source_game_state = gameseq_get_state();

	switch (Source_game_state) {

		case GS_STATE_MAIN_MENU:
			overlay_id = main_hall_get_overlay_id();
			resolution_index = main_hall_get_overlay_resolution_index();
			break;

		case GS_STATE_GAME_PLAY:
		case GS_STATE_GAME_PAUSED:
		case GS_STATE_TRAINING_PAUSED:
			gameseq_post_event(GS_EVENT_GAMEPLAY_HELP);
			break;

		case GS_STATE_BRIEFING:
			overlay_id = Briefing_overlay_id;
			break;

		case GS_STATE_SHIP_SELECT:
			overlay_id = Ship_select_overlay_id;
			break;

		case GS_STATE_WEAPON_SELECT:
			overlay_id = Weapon_select_overlay_id;
			break;

		case GS_STATE_BARRACKS_MENU:
			overlay_id = Barracks_overlay_id;
			break;

		case GS_STATE_CONTROL_CONFIG:
			overlay_id = Control_config_overlay_id;
			break;

		case GS_STATE_DEBRIEF:
			overlay_id = Debrief_overlay_id;
			break;

		case GS_STATE_MULTI_HOST_SETUP:
			overlay_id = Multi_create_overlay_id;
			break;

		case GS_STATE_MULTI_START_GAME:
			overlay_id = Multi_sg_overlay_id;
			break;

		case GS_STATE_MULTI_JOIN_GAME:
			overlay_id = Multi_join_overlay_id;
			break;

		case GS_STATE_HOTKEY_SCREEN:
			overlay_id = Hotkey_overlay_id;
			break;

		case GS_STATE_CAMPAIGN_ROOM:
			overlay_id = Campaign_room_overlay_id;
			break;

		case GS_STATE_SIMULATOR_ROOM:
			overlay_id = Sim_room_overlay_id;
			break;

		case GS_STATE_TECH_MENU:
			overlay_id = Techroom_overlay_id;
			break;

		case GS_STATE_CMD_BRIEF:
			overlay_id = Cmd_brief_overlay_id;
			break;

		default:
			nprintf(("Warning","WARNING ==> There is no context help available for state %s\n", GS_state_text[Source_game_state-1]));
			break;

	} // end switch

	if (overlay_id >= 0) {
		if ( !help_overlay_active(overlay_id) ) {
			help_overlay_set_state(overlay_id, resolution_index, 1);
		}
		else {
			help_overlay_set_state(overlay_id, resolution_index, 0);
		}
	}
}

void close_help(){
	for (int overlay_id=0; overlay_id<MAX_HELP_OVERLAYS; overlay_id++){
		if (help_overlaylist[overlay_id].textlist.size() > 0) {
			for(SCP_vector<help_text>::iterator ii = help_overlaylist[overlay_id].textlist.at(0).begin(); ii != help_overlaylist[overlay_id].textlist.at(0).end(); ++ii) {
				safe_kill(ii->string);
			}
		}
	}
}

// Called once at the beginning of the game to load help bitmaps & data
void help_overlay_init() 
{
	// load right_bracket bitmap
	help_right_bracket_bitmap = bm_load("right_bracket");
	// we failed to load the bitmap - this is very bad
	Assertion( help_right_bracket_bitmap >= 0, "Failed to load bitmap right_bracket for help overlay\n");

	// load left_bracket bitmap
	help_left_bracket_bitmap = bm_load("left_bracket");
	// we failed to load the bitmap - this is very bad
	Assertion( help_left_bracket_bitmap >= 0, "Failed to load bitmap left_bracket for help overlay\n");

	atexit(close_help);

	num_help_overlays = 0;

	// parse help.tbl
	parse_helptbl(HELP_OVERLAY_FILENAME);

	// look for any modular tables
	parse_modular_table(NOX("*-hlp.tbm"), parse_helptbl);
}

// parses help.tbl and populates help_overlaylist[]
void parse_helptbl(const char *filename)
{
	int overlay_id, currcount, vtxcount;
	char name[HELP_MAX_NAME_LENGTH];
	char buf[HELP_MAX_STRING_LENGTH + 1];
	int i, j;

	SCP_vector<help_pline> pline_temp;
	help_pline pline_temp2;
	SCP_vector<help_text> text_temp;
	help_text text_temp2;
	SCP_vector<help_right_bracket> rbracket_temp;
	help_right_bracket rbracket_temp2;
	SCP_vector<help_left_bracket> lbracket_temp;
	help_left_bracket lbracket_temp2;
	vec3d vec3d_temp;
	
	try
	{
		read_file_text(filename, CF_TYPE_TABLES);
		reset_parse();

		// for each overlay...
		while (optional_string("$")) {

			stuff_string(name, F_NAME, HELP_MAX_NAME_LENGTH);

			overlay_id = help_overlay_get_index(name);

			if (overlay_id < 0) {
				if (num_help_overlays >= MAX_HELP_OVERLAYS) {
					Warning(LOCATION, "Could not load help overlay '%s' as maximum number of help overlays was reached (Max is %d)", name, MAX_HELP_OVERLAYS);

					if (!skip_to_string("$end")) {
						Error(LOCATION, "Couldn't find $end. Help.tbl or -hlp.tbm is invalid.\n");
					}

					continue;
				}
				else {
					overlay_id = num_help_overlays;
					strcpy_s(help_overlaylist[overlay_id].name, name);
					num_help_overlays++;
				}
			}

			// clear out counters in the overlay struct
			help_overlaylist[overlay_id].plinecount = 0;
			help_overlaylist[overlay_id].textcount = 0;
			help_overlaylist[overlay_id].rbracketcount = 0;
			help_overlaylist[overlay_id].lbracketcount = 0;

			help_overlaylist[overlay_id].fontlist.clear();
			help_overlaylist[overlay_id].plinelist.clear();
			help_overlaylist[overlay_id].textlist.clear();
			help_overlaylist[overlay_id].rbracketlist.clear();
			help_overlaylist[overlay_id].lbracketlist.clear();

			if (optional_string("+resolutions")) {
				stuff_int(&help_overlaylist[overlay_id].num_resolutions);
			}
			else {
				help_overlaylist[overlay_id].num_resolutions = 2;
			}

			if (help_overlaylist[overlay_id].num_resolutions < 1) {
				Error(LOCATION, "+resolutions in %s is %d. (Must be 1 or greater)", filename, help_overlaylist[overlay_id].num_resolutions);
			}

			if (optional_string("+font")) {
				int font_index;
				for (i = 0; i < help_overlaylist[overlay_id].num_resolutions; i++) {
					stuff_int(&font_index);
					help_overlaylist[overlay_id].fontlist.push_back(font_index);
				}
			}
			else {
				for (i = 0; i < help_overlaylist[overlay_id].num_resolutions; i++) {
					help_overlaylist[overlay_id].fontlist.push_back(FONT1);
				}
			}

			for (i = 0; i < help_overlaylist[overlay_id].num_resolutions; i++) {
				help_overlaylist[overlay_id].plinelist.push_back(pline_temp);
				help_overlaylist[overlay_id].textlist.push_back(text_temp);
				help_overlaylist[overlay_id].rbracketlist.push_back(rbracket_temp);
				help_overlaylist[overlay_id].lbracketlist.push_back(lbracket_temp);
			}

			int type;
			// read in all elements for this overlay
			while ((type = required_string_one_of(5, "+pline", "+text", "+right_bracket", "+left_bracket", "$end")) != 4) {	// Doing it this way means an error lists "$end" at the end, which seems appropriate. -MageKing17

				switch (type) {
				case 0:	// +pline
					required_string("+pline");
					currcount = help_overlaylist[overlay_id].plinecount;
					int a, b;		// temp vars to read in int before cast to float;

					// read number of pline vertices
					stuff_int(&vtxcount);
					// get vertex coordinates for each resolution
					for (i = 0; i < help_overlaylist[overlay_id].num_resolutions; i++) {
						help_overlaylist[overlay_id].plinelist.at(i).push_back(pline_temp2);
						for (j = 0; j < vtxcount; j++) {
							help_overlaylist[overlay_id].plinelist.at(i).at(currcount).vtx.push_back(vec3d_temp);
							help_overlaylist[overlay_id].plinelist.at(i).at(currcount).vtxcount = vtxcount;
							stuff_int(&a);
							stuff_int(&b);
							help_overlaylist[overlay_id].plinelist.at(i).at(currcount).vtx.at(j).xyz.x = (float)a;
							help_overlaylist[overlay_id].plinelist.at(i).at(currcount).vtx.at(j).xyz.y = (float)b;
							help_overlaylist[overlay_id].plinelist.at(i).at(currcount).vtx.at(j).xyz.z = 0.0f;
						}
					}

					help_overlaylist[overlay_id].plinecount++;
					break;
				case 1:	// +text
					required_string("+text");
					currcount = help_overlaylist[overlay_id].textcount;

					// get coordinates for each resolution
					for (i = 0; i < help_overlaylist[overlay_id].num_resolutions; i++) {
						help_overlaylist[overlay_id].textlist.at(i).push_back(text_temp2);
						stuff_int(&(help_overlaylist[overlay_id].textlist.at(i).at(currcount).x_coord));
						stuff_int(&(help_overlaylist[overlay_id].textlist.at(i).at(currcount).y_coord));
					}

					// get string (always use the first resolution)
					stuff_string(buf, F_MESSAGE, sizeof(buf));
					help_overlaylist[overlay_id].textlist.at(0).at(currcount).string = vm_strdup(buf);

					help_overlaylist[overlay_id].textcount++;
					break;
				case 2: // +right_bracket
					required_string("+right_bracket");
					currcount = help_overlaylist[overlay_id].rbracketcount;

					// get coordinates for each resolution
					for (i = 0; i < help_overlaylist[overlay_id].num_resolutions; i++) {
						help_overlaylist[overlay_id].rbracketlist.at(i).push_back(rbracket_temp2);
						stuff_int(&(help_overlaylist[overlay_id].rbracketlist.at(i).at(currcount).x_coord));
						stuff_int(&(help_overlaylist[overlay_id].rbracketlist.at(i).at(currcount).y_coord));
					}

					help_overlaylist[overlay_id].rbracketcount++;
					break;
				case 3: // +left_bracket
					required_string("+left_bracket");
					currcount = help_overlaylist[overlay_id].lbracketcount;

					// get coordinates for each resolution
					for (i = 0; i < help_overlaylist[overlay_id].num_resolutions; i++) {
						help_overlaylist[overlay_id].lbracketlist.at(i).push_back(lbracket_temp2);
						stuff_int(&(help_overlaylist[overlay_id].lbracketlist.at(i).at(currcount).x_coord));
						stuff_int(&(help_overlaylist[overlay_id].lbracketlist.at(i).at(currcount).y_coord));
					}

					help_overlaylist[overlay_id].lbracketcount++;
					break;
				case -1:
					// -noparseerrors is set
					break;
				case 4: // $end
				default:
					Assertion(false, "This should never happen.\n");
					break;
				}
			}		// end while
			required_string("$end");
		}		// end while
	}
	catch (const parse::ParseException& e)
	{
		mprintf(("TABLES: Unable to parse '%s'!  Error message = %s.\n", filename, e.what()));
		return;
	}
}



// draw overlay on the screen
void help_overlay_blit(int overlay_id, int resolution_index)
{
	int idx, width, height;
	int plinecount = help_overlaylist[overlay_id].plinecount;
	int textcount = help_overlaylist[overlay_id].textcount;
	int rbracketcount = help_overlaylist[overlay_id].rbracketcount;
	int lbracketcount = help_overlaylist[overlay_id].lbracketcount;

	Assert(overlay_id >= 0 && overlay_id < MAX_HELP_OVERLAYS);

	// this draws each line of help text with white on black text (use the first resolution index for the string)
	gr_set_font(help_overlaylist[overlay_id].fontlist.at(resolution_index));
	for (idx = 0; idx < textcount; idx++) {
		gr_set_color_fast(&Color_black);
		gr_get_string_size(&width, &height, help_overlaylist[overlay_id].textlist.at(0).at(idx).string, strlen(help_overlaylist[overlay_id].textlist.at(0).at(idx).string));
		gr_rect(help_overlaylist[overlay_id].textlist.at(resolution_index).at(idx).x_coord-2*HELP_PADDING, help_overlaylist[overlay_id].textlist.at(resolution_index).at(idx).y_coord-3*HELP_PADDING, width+4*HELP_PADDING, height+4*HELP_PADDING, GR_RESIZE_MENU);
		gr_set_color_fast(&Color_bright_white);
		gr_printf_menu(help_overlaylist[overlay_id].textlist.at(resolution_index).at(idx).x_coord, help_overlaylist[overlay_id].textlist.at(resolution_index).at(idx).y_coord, help_overlaylist[overlay_id].textlist.at(0).at(idx).string);
	}
	gr_set_font(FONT1);

	// this draws each right bracket
	for (idx = 0; idx < rbracketcount; idx++) {
		gr_set_bitmap(help_right_bracket_bitmap);
		gr_bitmap(help_overlaylist[overlay_id].rbracketlist.at(resolution_index).at(idx).x_coord, help_overlaylist[overlay_id].rbracketlist.at(resolution_index).at(idx).y_coord, GR_RESIZE_MENU);
	}

	// this draws each left bracket
	for (idx = 0; idx < lbracketcount; idx++) {
		gr_set_bitmap(help_left_bracket_bitmap);
		gr_bitmap(help_overlaylist[overlay_id].lbracketlist.at(resolution_index).at(idx).x_coord, help_overlaylist[overlay_id].lbracketlist.at(resolution_index).at(idx).y_coord, GR_RESIZE_MENU);
	}	

	// this draws each 2d line for the help screen
	//gr_set_color_fast(&Color_yellow);
	gr_set_color(255, 255, 0);
	for (idx = 0; idx<plinecount; idx++) {
		gr_pline_special(&help_overlaylist[overlay_id].plinelist.at(resolution_index).at(idx).vtx, HELP_PLINE_THICKNESS, GR_RESIZE_MENU);
	}
}


// --------------------------------------------------
// DEBUGGING STUFF
// --------------------------------------------------
// z64: These DCF's really need a do-over.
DCF(help_reload, "Reloads help overlay data from help.tbl")
{
	if (dc_optional_string_either("help", "--help")) {
		dc_printf( "Usage: sample\nCrashes your machine.\n" );
	}

	num_help_overlays = 0;
	parse_helptbl(HELP_OVERLAY_FILENAME);
	parse_modular_table(NOX("*-hlp.tbm"), parse_helptbl);
}

int h_textnum=0, h_amt=0, h_vtx = 0;

void nudgetext_x(int textnum, int amount)
{
	help_overlaylist[current_helpid].textlist.at(current_resolution).at(textnum).x_coord += amount;
}
void nudgetext_y(int textnum, int amount)
{
	help_overlaylist[current_helpid].textlist.at(current_resolution).at(textnum).y_coord += amount;
}
void nudgepline_x(int plinenum, int plinevert, int amount)
{
	help_overlaylist[current_helpid].plinelist.at(current_resolution).at(plinenum).vtx[plinevert].xyz.x += amount;
}
void nudgepline_y(int plinenum, int plinevert, int amount)
{
	help_overlaylist[current_helpid].plinelist.at(current_resolution).at(plinenum).vtx[plinevert].xyz.y += amount;
}
void nudgerbracket_x(int num, int amount)
{
	help_overlaylist[current_helpid].rbracketlist.at(current_resolution).at(num).x_coord += amount;
}
void nudgerbracket_y(int num, int amount)
{
	help_overlaylist[current_helpid].rbracketlist.at(current_resolution).at(num).y_coord += amount;
}
void nudgelbracket_x(int num, int amount)
{
	help_overlaylist[current_helpid].lbracketlist.at(current_resolution).at(num).x_coord += amount;
}
void nudgelbracket_y(int num, int amount)
{
	help_overlaylist[current_helpid].lbracketlist.at(current_resolution).at(num).y_coord += amount;
}
void showtextpos(int textnum)
{
	dc_printf("text %d is now located at (%d, %d)", textnum, help_overlaylist[current_helpid].textlist.at(current_resolution).at(textnum).x_coord, help_overlaylist[current_helpid].textlist.at(current_resolution).at(textnum).y_coord );
}
void showrbracketpos(int num)
{
	dc_printf("rbracket %d is now located at (%d, %d)", num, help_overlaylist[current_helpid].rbracketlist.at(current_resolution).at(num).x_coord, help_overlaylist[current_helpid].rbracketlist.at(current_resolution).at(num).y_coord );
}
void showlbracketpos(int num)
{
	dc_printf("lbracket %d on overlay %d is now located at (%d, %d)", num, current_helpid, help_overlaylist[current_helpid].lbracketlist.at(current_resolution).at(num).x_coord, help_overlaylist[current_helpid].lbracketlist.at(current_resolution).at(num).y_coord );
}
void showplinepos(int plinenum)
{
	int i;
	dc_printf("pline %d on overlay %d vertices are now ", plinenum, current_helpid, help_overlaylist[current_helpid].textlist.at(current_resolution).at(plinenum).y_coord );
	for (i=0; i<help_overlaylist[current_helpid].plinelist.at(gr_screen.res).at(plinenum).vtxcount; i++)
	{
		dc_printf("(%3.0f %3.0f) ", help_overlaylist[current_helpid].plinelist.at(current_resolution).at(plinenum).vtx.at(i).xyz.x, help_overlaylist[current_helpid].plinelist.at(current_resolution).at(plinenum).vtx.at(i).xyz.y);
	}
}

DCF(help_nudgetext_x, "Use to visually position overlay text.")
{

	if (dc_optional_string_either("help", "--help")) {
		dc_printf( "Usage: sample\nCrashes your machine.\n" );
		return;
	}

	if (dc_optional_string_either("status", "--status") || dc_optional_string_either("?", "--?")) {
		showtextpos(h_textnum);
		return;
	}

	dc_stuff_int(&h_textnum);
	dc_stuff_int(&h_amt);

	nudgetext_x(h_textnum, h_amt);
}

DCF(help_nudgetext_y, "Use to visually position overlay text.")
{
	if (dc_optional_string_either("help", "--help")) {
		dc_printf( "Usage: sample\nCrashes your machine.\n" );
		return;
	}

	if (dc_optional_string_either("status", "--status") || dc_optional_string_either("?", "--?")) {
		showtextpos(h_textnum);
		return;
	}

	dc_stuff_int(&h_textnum);
	dc_stuff_int(&h_amt);
	
	nudgetext_y(h_textnum, h_amt);
}

DCF(help_nudgepline_x, "Use to visually position overlay polylines.")
{
		if (dc_optional_string_either("help", "--help")) {
		dc_printf( "Usage: help_nudgepline [pline_number] [vertex_number] [distance]\n" );
		return;
	}

	if (dc_optional_string_either("status", "--status") || dc_optional_string_either("?", "--?"))	{
		showplinepos(h_textnum);
		return;
	}

	dc_stuff_int(&h_textnum);
	dc_stuff_int(&h_vtx);
	dc_stuff_int(&h_amt);

	nudgepline_x(h_textnum, h_vtx, h_amt);
}


DCF(help_nudgepline_y, "Use to visually position overlay polylines.")
{
	if (dc_optional_string_either("help", "--help")) {
		dc_printf( "Usage: help_nudgepline [pline_number] [vertex_number] [distance]\n" );
		return;
	}

	if (dc_optional_string_either("status", "--status") || dc_optional_string_either("?", "--?"))	{
		showplinepos(h_textnum);
		return;
	}

	dc_stuff_int(&h_textnum);
	dc_stuff_int(&h_vtx);
	dc_stuff_int(&h_amt);

	nudgepline_y(h_textnum, h_vtx, h_amt);
}


DCF(help_nudgerbracket_x, "Use to visually position overlay right bracket.")
{
	if (dc_optional_string_either("help", "--help")) {
		dc_printf( "Usage: help_nudgerbracket_x [num] [amount]\n" );
		return;
	}

	if (dc_optional_string_either("status", "--status") || dc_optional_string_either("?", "--?"))	{
		showrbracketpos(h_textnum);
		return;
	}

	dc_stuff_int(&h_textnum);
	dc_stuff_int(&h_amt);

	nudgerbracket_x(h_textnum, h_amt);
}

DCF(help_nudgerbracket_y, "Use to visually position overlay right bracket.")
{
	if (dc_optional_string_either("help", "--help")) {
		dc_printf( "Usage: help_nudgerbracket_y [num] [amount]\n" );
		return;
	}

	if (dc_optional_string_either("status", "--status") || dc_optional_string_either("?", "--?"))	{
		showrbracketpos(h_textnum);
		return;
	}

	dc_stuff_int(&h_textnum);
	dc_stuff_int(&h_amt);
	
	nudgerbracket_y(h_textnum, h_amt);
}




DCF(help_nudgelbracket_x, "Use to visually position overlay left bracket.")
{

	if (dc_optional_string_either("help", "--help")) {
		dc_printf( "Usage: help_nudgelbracket_x [num] [amount]\n" );
		return;
	}

	if (dc_optional_string_either("status", "--status") || dc_optional_string_either("?", "--?")) {
		showlbracketpos(h_textnum);
		return;
	}

	dc_stuff_int(&h_textnum);
	dc_stuff_int(&h_amt);

	nudgelbracket_x(h_textnum, h_amt);
}

DCF(help_nudgelbracket_y, "Use to visually position overlay left bracket.")
{
	if (dc_optional_string_either("help", "--help")) {
		dc_printf( "Usage: help_nudgelbracket_y [num] [amount]\n" );
		return;
	}

	if (dc_optional_string_either("status", "--status") || dc_optional_string_either("?", "--?"))	{
		showlbracketpos(h_textnum);
		return;
	}

	dc_stuff_int(&h_textnum);
	dc_stuff_int(&h_amt);

	nudgelbracket_y(h_textnum, h_amt);
}