void s_right_menu(void){
//-----------------------------------------------------------------------------------------------------
// Purpose: Display a scrolling menu for the right button
// Rev: 1.0 Initial Release
// Notes: Currently displays NC State Song
//-----------------------------------------------------------------------------------------------------
int index = ad0/SONG;
if (index > UNDER) end = ON;
if (index == SHIGH && beginning == ON){
//beginning = OFF;
end = OFF;
}
if (end == ON && index <= SHIGH){
offset = SHIGH - index;
index = SHIGH + offset;
}
if (index<ABOVE) beginning = OFF;
if (index == SHIGH && beginning == ON){
end = OFF;
}
if (end == ON && index >= LIMIT_A) beginning = ON;
if (index+ABOVE == LENGTH) {
DisplayString(LCD_LINE1, "STOP ");
DisplayString(LCD_LINE2, "STOP ");
}
else {
DisplayString(LCD_LINE1, r_menu[index].lyric);
DisplayString(LCD_LINE2, r_menu[index].color);
}
}
static int EMMMessage(void)
{
static char MouseErrMsg1[]="·¢ÏÖEMM386ÒѾÔËÐÐ,ÈôÄúÔÚÔËÐб¾";
static char MouseErrMsg2[]="Èí¼þ¹ý³ÌÖз¢ÏÖÓÐÒì³££¬Çë¹Ø±ÕEMM386¡£";
static char MouseErrMsg3[]="[½«Config.sysÖÐµÄ device=EMM386 ɾ³ý";
static char MouseErrMsg4[]="»òÓà REM ×¢Ê͵ô»òн¨Ò»²Ëµ¥Ñ¡Ïî]";
static char MouseErrMsg5[]=" ÏÖÔÚÄú¿É°´<Esc>Í˳ö, ±ðµÄ¼ü½«¼ÌÐø";
int x=getmaxx(),y=getmaxy();
int disp_x=x/2-(strlen(MouseErrMsg2)+4)*ASC16WIDTH/2;
int disp_y=y/2-10;
int Result;
setfillstyle(1,EGA_BLACK);
bar(0,0,x,y-40);
DisplayString(MouseErrMsg1,disp_x+4*ASC16WIDTH,disp_y-3*ASC16HIGHT-4,
EGA_WHITE,EGA_BLACK);
DisplayString(MouseErrMsg2,disp_x,disp_y-2*ASC16HIGHT,
EGA_WHITE,EGA_BLACK);
DisplayString(MouseErrMsg3,disp_x,disp_y-1*ASC16HIGHT+4,
EGA_WHITE,EGA_BLACK);
DisplayString(MouseErrMsg4,disp_x,disp_y-0*ASC16HIGHT+8,
EGA_WHITE,EGA_BLACK);
DisplayString(MouseErrMsg5,disp_x,disp_y+1*ASC16HIGHT+20,
EGA_WHITE,EGA_BLACK);
fflush(stdout);
Result=getch();
if(Result==0) getch();
else if(Result==ESC) return(-1);
while (kbhit()) getch();
return 0;
}
static int
gdk_x_io_error (Display *display)
{
/* This is basically modelled after the code in XLib. We need
* an explicit error handler here, so we can disable our atexit()
* which would otherwise cause a nice segfault.
* We fprintf(stderr, instead of g_warning() because g_warning()
* could possibly be redirected to a dialog
*/
if (errno == EPIPE)
{
g_warning ("The application '%s' lost its connection to the display %s;\n"
"most likely the X server was shut down or you killed/destroyed\n"
"the application.\n",
g_get_prgname (),
display ? DisplayString (display) : gdk_get_display_arg_name ());
}
else
{
g_warning ("%s: Fatal IO error %d (%s) on X server %s.\n",
g_get_prgname (),
errno, g_strerror (errno),
display ? DisplayString (display) : gdk_get_display_arg_name ());
}
_exit (1);
}
void CoShutdown(int mode)
{
if (!DisplayIsOn()) {
DisplayInit();
}
DisplayString("Shutting down.\n");
DisplayString("Done.\n");
switch (mode) {
case SD_WAIT:
while (1)
;
case SD_OFF:
HalShutdown();
break;
case SD_REBOOT:
HalReboot();
while (1)
;
default:
while (1)
;
}
}
static int gui_x_io_error (Display *display) {
/*
* The X I/O error handling routine.
*
* Arguments:
* "display" is the X display the error orignated from.
*
* Results:
* An X I/O error basically means we lost our connection
* to the X server. There is not much we can do to
* continue, so simply print an error message and exit.
*
*/
/* This is basically modelled after the code in XLib. We need
* an explicit error handler here, so we can disable our atexit()
* which would otherwise cause a nice segfault.
*/
if (errno == EPIPE) {
fprintf(SE_ERR,
"GUI-ERROR **: X connection to %s broken (explicit kill or server shutdown).\n",
gdk_display ? DisplayString(gdk_display) : gdk_display_name);
}
else {
fprintf(SE_ERR,
"Gdk-ERROR **: Fatal IO error %d (%s) on X server %s.\n",
errno, basic_gui_strerror(errno),
gdk_display ? DisplayString(gdk_display) : gdk_display_name);
}
#ifdef SE_NO_CHECK
error0("gui_x_io_error.", NULL);
#endif
exit(1);
}
void s_left_menu(void){
//-----------------------------------------------------------------------------------------------------
// Purpose: Display a scrolling menu for the left button
// Rev: 1.0 Initial Release
// Notes: Currently displays Resistor Codes
//-----------------------------------------------------------------------------------------------------
int index = ad0/RESISTORS;
DisplayString(LCD_LINE1, l_menu[index].value);
DisplayString(LCD_LINE2, l_menu[index].color);
beginning = OFF;
end = OFF;
}
void Tools::DisplayCommon::DisplayMetaDataConnections( FbxObject* pObject )
{
int totalMetaData = pObject->GetSrcObjectCount<FbxObjectMetaData>();
if( totalMetaData > 0 )
DisplayString( " MetaData connections " );
for( int i = 0; i < totalMetaData; i++ )
{
FbxObjectMetaData *metaData = pObject->GetSrcObject<FbxObjectMetaData>( i );
DisplayString( " Name: ", (char*)metaData->GetName() );
}
}
void s_mid_menu(void){
//-----------------------------------------------------------------------------------------------------
// Purpose: Display a scrolling menu for the middle button
// Rev: 1.0 Initial Release
// Notes: Currently displays Shapes
//-----------------------------------------------------------------------------------------------------
int index = ad0/SHAPES;
DisplayString(LCD_LINE1, m_menu[index]);
if (index+ABOVE == SIZE) DisplayString(LCD_LINE2, "STOP ");
else DisplayString(LCD_LINE2, m_menu[index+ABOVE]);
beginning = OFF;
end = OFF;
}
/*
* Interrupt handler for X IO errors
*/
static int HandleXIOError(Display *d)
{
char msg[BUFSIZE];
if (errno == EPIPE) {
sprintf(msg, "X connection to %s broken (server error - EPIPE).",
DisplayString(d));
} else {
sprintf(msg, "Fatal IO error on X server %s.", DisplayString(d));
}
emergency_exit(gapp, FALSE, msg);
/* Ideally, we don't reach this anyway ... */
return 1;
}
static BOOL
InitMainWnd(PMAIN_WND_INFO Info)
{
HANDLE DevEnumThread;
HMENU hMenu;
if (!pCreateToolbar(Info))
DisplayString(_T("error creating toolbar"));
if (!CreateTreeView(Info))
{
DisplayString(_T("error creating list view"));
return FALSE;
}
if (!CreateStatusBar(Info))
DisplayString(_T("error creating status bar"));
UpdateViewMenu(Info);
/* make 'properties' bold */
hMenu = GetMenu(Info->hMainWnd);
hMenu = GetSubMenu(hMenu, 1);
SetMenuDefaultItem(hMenu, IDC_PROP, FALSE);
/* Create Popup Menu */
Info->hShortcutMenu = LoadMenu(hInstance,
MAKEINTRESOURCE(IDR_POPUP));
Info->hShortcutMenu = GetSubMenu(Info->hShortcutMenu,
0);
SetMenuDefaultItem(Info->hShortcutMenu, IDC_PROP, FALSE);
/* create seperate thread to emum devices */
DevEnumThread = CreateThread(NULL,
0,
DeviceEnumThread,
Info,
0,
NULL);
if (!DevEnumThread)
{
DisplayString(_T("Failed to enumerate devices"));
return FALSE;
}
CloseHandle(DevEnumThread);
return TRUE;
}
void _DisplayUrl(const char * caller, pUrlChainType pThisUrlChainPar)
{
pUrlChainType pThisUrlChain = pThisUrlChainPar;
/* process each entry of chain */
while (NULL != pThisUrlChain)
{
if (NULL != pThisUrlChain->pCompound)
{
DXMLAUX("\t[%s]: pCompund is not NULL, its contents are:\n", caller);
DisplayCompound(pThisUrlChain->pCompound);
}
if (NULL != pThisUrlChain->pCompound)
{
DXMLAUX("\t[%s]: Cumulative resulting URL is :\n", caller);
DisplayString(pThisUrlChain->pcSumm);
}
/* Go to next record of Chainwork */
pThisUrlChain = pThisUrlChain->pNextChain;
};
}
/** Execute an external program. */
void RunCommand(const char *command) {
const char *displayString;
char *str;
if(JUNLIKELY(!command)) {
return;
}
displayString = DisplayString(display);
if(!fork()) {
close(ConnectionNumber(display));
if(displayString && displayString[0]) {
str = malloc(strlen(displayString) + 9);
sprintf(str, "DISPLAY=%s", displayString);
putenv(str);
}
setsid();
execl(SHELL_NAME, SHELL_NAME, "-c", command, NULL);
Warning(_("exec failed: (%s) %s"), SHELL_NAME, command);
exit(EXIT_SUCCESS);
}
}
static int Xerror(Display *d, XErrorEvent *error) {
X_UNLOCK;
if (getenv("X11VNC_PRINT_XERROR")) {
fprintf(stderr, "Xerror: major_opcode: %d minor_opcode: %d error_code: %d\n",
error->request_code, error->minor_code, error->error_code);
}
if (xshm_opcode > 0 && error->request_code == xshm_opcode) {
if (error->minor_code == X_ShmAttach) {
char *dstr = DisplayString(dpy);
fprintf(stderr, "\nX11 MIT Shared Memory Attach failed:\n");
fprintf(stderr, " Is your DISPLAY=%s on a remote machine?\n", dstr);
if (strstr(dstr, "localhost:")) {
fprintf(stderr, " Note: DISPLAY=localhost:N suggests a SSH X11 redir to a remote machine.\n");
} else if (dstr[0] != ':') {
fprintf(stderr, " Note: DISPLAY=hostname:N suggests a remote display.\n");
}
fprintf(stderr, " Suggestion, use: x11vnc -display :0 ... for local display :0\n\n");
}
}
interrupted(0);
if (d) {} /* unused vars warning: */
return (*Xerror_def)(d, error);
}
VALUE
subSubtleSingDisplayReader(VALUE self)
{
subSubtlextConnect(NULL); ///< Implicit open connection
return rb_str_new2(DisplayString(display));
} /* }}} */
/**
* gst_gl_display_x11_new_with_display:
* @display: an existing, x11 display
*
* Creates a new display connection from a X11 Display.
*
* Returns: (transfer full): a new #GstGLDisplayX11
*/
GstGLDisplayX11 *
gst_gl_display_x11_new_with_display (Display * display)
{
GstGLDisplayX11 *ret;
g_return_val_if_fail (display != NULL, NULL);
GST_DEBUG_CATEGORY_GET (gst_gl_display_debug, "gldisplay");
ret = g_object_new (GST_TYPE_GL_DISPLAY_X11, NULL);
ret->name = g_strdup (DisplayString (display));
ret->display = display;
ret->xcb_connection = XGetXCBConnection (ret->display);
if (!ret->xcb_connection) {
GST_ERROR ("Failed to open retieve XCB connection from X11 Display");
gst_object_unref (ret);
return NULL;
}
ret->foreign_display = TRUE;
return ret;
}
int qtopia_display_id()
{
#if defined(Q_WS_QWS)
extern int qws_display_id;
return qws_display_id;
#elif defined(Q_WS_X11)
Display *dpy = QX11Info::display();
QString name;
if ( dpy ) {
name = QString( DisplayString( dpy ) );
} else {
const char *d = getenv("DISPLAY");
if ( !d )
return 0;
name = QString( d );
}
int index = name.indexOf(QChar(':'));
if ( index >= 0 )
return name.mid(index + 1).toInt();
else
return 0;
#else
return 0;
#endif
}
void DisplayMessage::DisplayString(int stridx, unsigned int color, ieDword flags) const
{
if (stridx<0) return;
char* text = core->GetString( stridx, flags);
DisplayString(text, color, NULL);
core->FreeString(text);
}
static VOID
OnRefresh(PMAIN_WND_INFO Info)
{
HANDLE DevEnumThread;
SendMessage(Info->hTool,
TB_SETSTATE,
IDC_PROP,
(LPARAM)MAKELONG(TBSTATE_INDETERMINATE, 0));
EnableMenuItem(GetMenu(Info->hMainWnd), IDC_PROP, MF_GRAYED);
EnableMenuItem(Info->hShortcutMenu, IDC_PROP, MF_GRAYED);
/* create seperate thread to emum devices */
DevEnumThread = CreateThread(NULL,
0,
DeviceEnumThread,
Info,
0,
NULL);
if (!DevEnumThread)
{
DisplayString(_T("Failed to enumerate devices"));
return;
}
CloseHandle(DevEnumThread);
}
static void DispXY(int x,int y,char *s,int color)
{
//setwritemode(COPY_PUT);
DisplayString(s,x,y,color,EGA_LIGHTGRAY);
//setwritemode(COPY_PUT);
/*
int SaveColor;
struct viewporttype SaveViewPort;
MouseHidden();
getviewsettings(&SaveViewPort);
SaveColor=getcolor();
setwritemode(COPY_PUT);
setcolor(EGA_DARKGRAY); //gray
setviewport(0,0,getmaxx(),getmaxy(),1);
DisplayString(s,x,y,color,EGA_LIGHTGRAY);
setwritemode(COPY_PUT);
setcolor(SaveColor);
setviewport(SaveViewPort.left,SaveViewPort.top,SaveViewPort.right,
SaveViewPort.bottom,SaveViewPort.clip);
MouseShow();
*/
}
//simply displaying a constant string
void DisplayMessage::DisplayConstantString(int stridx, unsigned int color, Scriptable *target) const
{
if (stridx<0) return;
char* text = core->GetString( strref_table[stridx], IE_STR_SOUND );
DisplayString(text, color, target);
core->FreeString(text);
}
void XDesktopContainer::initXWin()
{
display = XOpenDisplay(NULL);
if (!display){
cout << "Display is null!!\n";
_exit(1);
}
char *name = DisplayString(display);
int screen = DefaultScreen(display);
rootWindow = RootWindow(display, screen);
XTextProperty prop;
Atom start = XInternAtom(display,"_IDESK_START", false);
cout << " Idesk starting in " << name << endl;
prop.value = (unsigned char *)name;
prop.encoding = XA_STRING;
prop.format = 8;
prop.nitems = strlen(name);
XSetTextProperty(display, rootWindow, &prop, start);
XSelectInput( display, rootWindow, PropertyChangeMask| SubstructureNotifyMask);
XSync(display, false);
}
//=====================================
// XQuery run query...
//-------------------------------------
QString* XQuery::run (void) {
QString optd ("-d");
QString dpy (DisplayString (x11Display()));
if (mArg.isEmpty()) {
if (! errorCheck) {
*mResult = qx ( XQUERY,STDOUT,3,"%s %s %s",
optd.ascii(),dpy.ascii(),mOpt.ascii()
);
} else {
*mResult = qx ( XQUERY,STDERR,3,"%s %s %s",
optd.ascii(),dpy.ascii(),mOpt.ascii()
);
}
} else {
if (! errorCheck) {
*mResult = qx ( XQUERY,STDOUT,4,"%s %s %s %s",
optd.ascii(),dpy.ascii(),mOpt.ascii(),mArg.ascii()
);
} else {
*mResult = qx ( XQUERY,STDERR,4,"%s %s %s %s",
optd.ascii(),dpy.ascii(),mOpt.ascii(),mArg.ascii()
);
}
}
return (mResult);
}
gkString getNativeWinHandleFromWxWin(wxWindow* win)
{
gkString handle;
if (!win) return handle;
#ifdef WIN32
handle = Ogre::StringConverter::toString((size_t)((HWND)win->GetHandle()));
#elif defined(__WXGTK__)
// copied from wxOgreMVC
// handle format: display:screen:window of types ulong:uint:ulong
GtkWidget* widget = win->GetHandle();
gtk_widget_realize( widget ); // Mandatory. Otherwise, a segfault happens.
Ogre::StringUtil::StrStreamType handleStream;
Display* display = GDK_WINDOW_XDISPLAY( widget->window );
Window wid = GDK_WINDOW_XWINDOW( widget->window ); // Window is a typedef for XID, which is a typedef for unsigned int
// Get the right display (DisplayString() returns ":display.screen")
gkString displayStr = DisplayString( display );
displayStr = displayStr.substr( 1, ( displayStr.find( ".", 0 ) - 1 ) );
// Put all together
handleStream << displayStr << ':' << DefaultScreen( display ) << ':' << wid;
handle = handleStream.str();
#else
#error Not supported yet!
#endif
return handle;
}
/**
* Do deferred logging after initialisation
*/
void doXKeyboardLogging(Display *dpy)
{
if (((1 == gfByTypeOK) || (1 == gfByXkbOK)) && (gfByLayoutOK != 1))
dumpLayout(dpy);
if (((1 == gfByLayoutOK) || (1 == gfByXkbOK)) && (gfByTypeOK != 1))
dumpType(dpy);
if ((gfByLayoutOK != 1) && (gfByTypeOK != 1) && (gfByXkbOK != 1))
{
LogRel(("Failed to recognize the keyboard mapping or to guess it based on\n"
"the keyboard layout. It is very likely that some keys will not\n"
"work correctly in the guest. If this is the case, please submit\n"
"a bug report, giving us information about your keyboard type,\n"
"its layout and other relevant information such as whether you\n"
"are using a remote X server or something similar. \n"));
unsigned *keyc2scan = X11DRV_getKeyc2scan();
LogRel(("The keycode-to-scancode table is: %d=%d",0,keyc2scan[0]));
for (int i = 1; i < 256; i++)
LogRel((",%d=%d",i,keyc2scan[i]));
LogRel(("\n"));
}
LogRel(("X Server details: vendor: %s, release: %d, protocol version: %d.%d, display string: %s\n",
ServerVendor(dpy), VendorRelease(dpy), ProtocolVersion(dpy),
ProtocolRevision(dpy), DisplayString(dpy)));
LogRel(("Using %s for keycode to scan code conversion\n",
gfByXkbOK ? "XKB"
: gfByTypeOK ? "known keycode mapping"
: "host keyboard layout detection"));
}
//simply displaying a constant string
void DisplayMessage::DisplayConstantString(int stridx, unsigned int color, Scriptable *target) const
{
if (stridx<0) return;
String* text = core->GetString( DisplayMessage::SRefs[stridx], IE_STR_SOUND );
DisplayString(*text, color, target);
delete text;
}
/*
* Create a balloon-evaluation area for a Widget.
* There can be either a "mesg" for a fixed string or "mesgCB" to generate a
* message by calling this callback function.
* When "mesg" is not NULL it must remain valid for as long as the balloon is
* used. It is not freed here.
* Returns a pointer to the resulting object (NULL when out of memory).
*/
BalloonEval *
gui_mch_create_beval_area(
void *target,
char_u *mesg,
void (*mesgCB)(BalloonEval *, int),
void *clientData)
{
#ifndef FEAT_GUI_GTK
char *display_name; /* get from gui.dpy */
int screen_num;
char *p;
#endif
BalloonEval *beval;
if (mesg != NULL && mesgCB != NULL)
{
IEMSG(_("E232: Cannot create BalloonEval with both message and callback"));
return NULL;
}
beval = (BalloonEval *)alloc_clear(sizeof(BalloonEval));
if (beval != NULL)
{
#ifdef FEAT_GUI_GTK
beval->target = GTK_WIDGET(target);
#else
beval->target = (Widget)target;
beval->appContext = XtWidgetToApplicationContext((Widget)target);
#endif
beval->showState = ShS_NEUTRAL;
beval->msg = mesg;
beval->msgCB = mesgCB;
beval->clientData = clientData;
/*
* Set up event handler which will keep its eyes on the pointer,
* and when the pointer rests in a certain spot for a given time
* interval, show the beval.
*/
addEventHandler(beval->target, beval);
createBalloonEvalWindow(beval);
#ifndef FEAT_GUI_GTK
/*
* Now create and save the screen width and height. Used in drawing.
*/
display_name = DisplayString(gui.dpy);
p = strrchr(display_name, '.');
if (p != NULL)
screen_num = atoi(++p);
else
screen_num = 0;
beval->screen_width = DisplayWidth(gui.dpy, screen_num);
beval->screen_height = DisplayHeight(gui.dpy, screen_num);
#endif
}
return beval;
}
int
rxvt_xioerror_handler (Display *display)
{
rxvt_warn ("X connection to '%s' broken, unable to recover, exiting.\n",
DisplayString (display));
rxvt_emergency_cleanup ();
_exit (EXIT_FAILURE);
}
void DisplayMessage::DisplayString(int stridx, unsigned int color, ieDword flags) const
{
if (stridx<0) return;
String* text = core->GetString( stridx, flags);
DisplayString(*text, color, NULL);
delete text;
}
QXlibDisplay::QXlibDisplay(Display *display)
: mDisplay(display)
{
if (!mDisplay) {
qFatal("Cannot connect to X server");
}
mDisplayName = QString::fromLocal8Bit(DisplayString(mDisplay));
}
//=====================================
// set cursor for root window...
//-------------------------------------
void setMouseCursor (const QString& cursorName) {
QString optc ("-cursor_name");
QString optd ("-display");
QString display ( DisplayString ( QApplication::desktop()->x11Display() ));
qx (XSETROOT,STDNONE,4,"%s %s %s %s",
optc.ascii(),cursorName.ascii(),optd.ascii(),display.ascii()
);
}
