Gedichte Musik Bilder Quellcodebibliothek Diashow Normaldarstellung
feedback image not shown  

Quellcode-Bibliothek

© Kompilation durch diese Firma

[Weder Korrektheit noch Funktionsfähigkeit der Software werden zugesichert.]

Datei: coqide_main.ml   Sprache: C

Original von: Lyx©
#include <config.h>

#include "lyxdraw.h"
#include "error.h"

extern int reverse_video;
extern int mono_video;
extern char label_color[];
extern char math_color[];
extern char math_frame_color[];
extern char latex_color[];
extern char foot_color[];
extern char new_line_color[];
extern char fill_color[];
extern int fast_selection;
extern char on_off_line_color[];
extern LString background_color;
extern char lighted_color[];
extern char selection_color[];
extern char note_color[];
extern char note_frame_color[];

Colormap color_map = 0;
long int background_pixels;

// X11 color names
char const * const X11Color[11] =
{ "black", "black", "white", "red", "green", "blue", "cyan", "magenta", 
  "yellow", "black", "black" };
 
// Different graphic contexts
static GC clear_gc = NULL;
static GC latex_gc = NULL;
static GC foot_gc = NULL;
static GC new_line_gc = NULL;
static GC math_gc = NULL;
static GC math_frame_gc = NULL;
static GC fill_gc = NULL;
static GC note_gc = NULL;
static GC note_frame_gc = NULL;
static GC copy_gc = NULL;
static GC select_gc = NULL;
static GC on_off_line_gc = NULL;
static GC thin_on_off_line_gc = NULL;
static GC thick_line_gc = NULL;
static GC lighted_gc = NULL;
static GC selection_gc = NULL;
static GC accent_gc[10] = { NULL, NULL, NULL, NULL, NULL,
       NULL, NULL, NULL, NULL, NULL };
static GC color_gc[11] = { NULL, NULL, NULL, NULL, NULL, NULL,
      NULL, NULL, NULL, NULL, NULL };
static GC minipage_gc = NULL;


// Allocates color and sets it as foreground
// Returns "false" if unsuccesful
bool setForegroundColor(char const * const color, XGCValues & val)
{
 XColor xcol;
 if (!color_map) {
  color_map = fl_state[fl_get_vclass()].colormap;
 }
 if (!mono_video) {
  if (XParseColor(fl_display, color_map, color, &xcol)
      && XAllocColor(fl_display, color_map, &xcol))
  {
   val.foreground = xcol.pixel;
  } else {
   lyxerr.print(LString("LyX: Couldn't get color ") + color);
   return false;
  }
 }
 return true;
}


static
void do_reverse_video(XGCValues &val)
{
 if (reverse_video) {
  val.foreground=WhitePixel(fl_display,
       DefaultScreen(fl_display));
  val.background=BlackPixel(fl_display,
       DefaultScreen(fl_display));
 } else {
  val.foreground=BlackPixel(fl_display,
       DefaultScreen(fl_display));
  val.background=WhitePixel(fl_display,
       DefaultScreen(fl_display));
 }
}


static
GC make_normal_gc(const char* color)
{
 XGCValues val;
 do_reverse_video(val);
 val.function = GXcopy;
 val.graphics_exposures = false;
 setForegroundColor(color, val);
 return XCreateGC(fl_display, fl_root,
    GCBackground | GCForeground | GCFunction |
    GCGraphicsExposures, &val);
}


static
GC GetNoteGC()
{
 if (note_gc) return note_gc;
 
  note_gc = make_normal_gc(note_color);

 return note_gc;
}


static
GC GetNoteFrameGC()
{
 if (note_frame_gc) return note_frame_gc;
 
  note_frame_gc = make_normal_gc(note_frame_color);

 return note_frame_gc;
}


static
GC GetMathGC()
{
 if (math_gc) return math_gc;
 
  math_gc = make_normal_gc(math_color);

 return math_gc;
}


static
GC GetLatexGC()
{
 if (latex_gc) return latex_gc;

 XGCValues val;
 if (reverse_video ^ mono_video) {
  val.foreground=WhitePixel(fl_display, DefaultScreen(fl_display));
  val.background=BlackPixel(fl_display, DefaultScreen(fl_display));
 } else {
  val.foreground=BlackPixel(fl_display, DefaultScreen(fl_display));
  val.background=WhitePixel(fl_display, DefaultScreen(fl_display));
 }
 val.function=GXcopy;
 val.graphics_exposures = false;
 setForegroundColor(latex_color, val);
 latex_gc = XCreateGC(fl_display, fl_root, GCBackground 
        | GCForeground | GCFunction | GCGraphicsExposures, 
        &val);
 XFlush(fl_display);
 
 return latex_gc;
}


static
GC GetFootGC()
{
 if (foot_gc) return foot_gc;
 
 foot_gc = make_normal_gc(foot_color);
 
 return foot_gc;
}


static
GC GetNewLineGC()
{
        if (new_line_gc) return new_line_gc;
 
        new_line_gc = make_normal_gc(new_line_color);
 
        return new_line_gc;
}
 
 
static
GC GetMathFrameGC()
{
 if (math_frame_gc) return math_frame_gc;
 
 math_frame_gc = make_normal_gc(math_frame_color);
 
 return math_frame_gc;
}


static
GC GetFillGC()
{
 if (fill_gc) return fill_gc;
 
 fill_gc = make_normal_gc(fill_color);
 
 return fill_gc;
}


static
GC GetClearGC()
{
 if (clear_gc) return clear_gc;
 
 XGCValues val;

 if (reverse_video) {
  val.foreground=BlackPixel(fl_display,
       DefaultScreen(fl_display));
  val.background=WhitePixel(fl_display,
       DefaultScreen(fl_display));
 } else {
  val.background=BlackPixel(fl_display,
       DefaultScreen(fl_display));
  val.foreground=WhitePixel(fl_display,
       DefaultScreen(fl_display));
 }
 val.function=GXcopy;
 val.graphics_exposures = false;
 if (!fast_selection && background_color != "white") {
  setForegroundColor(background_color.c_str(), val);
 }
 background_pixels = val.foreground;
 
 clear_gc = XCreateGC(fl_display, fl_root, GCBackground 
        | GCForeground | GCFunction | GCGraphicsExposures, 
        &val);
 XFlush(fl_display);
 
 return clear_gc;
}


static
GC GetOnOffLineGC()
{
 if (on_off_line_gc) return on_off_line_gc;
 
 XGCValues val;
 do_reverse_video(val);

 val.function=GXcopy;
 val.graphics_exposures = false;
 setForegroundColor(on_off_line_color, val);
 val.line_width = 0;
 val.line_style = LineOnOffDash;
 on_off_line_gc = XCreateGC(fl_display, fl_root,
       GCBackground | GCForeground | GCFunction |
       GCGraphicsExposures | GCLineWidth |
       GCLineStyle , &val);
 XFlush(fl_display);

 return on_off_line_gc;
}


static
GC GetThickLineGC()
{
 if (thick_line_gc) return thick_line_gc;
 XGCValues val;
 do_reverse_video(val);

 val.function=GXcopy;
 val.graphics_exposures = false;
 val.line_width = 2;
 val.line_style = LineSolid;
 thick_line_gc = XCreateGC(fl_display, fl_root, GCBackground 
      | GCForeground | GCFunction | GCGraphicsExposures
      | GCLineWidth | GCLineStyle , &val);
 XFlush(fl_display);
 
 return thick_line_gc;
}


static
GC GetThinOnOffLineGC()
{
 if (thin_on_off_line_gc) return thin_on_off_line_gc;
 XGCValues val;
 do_reverse_video(val);

 val.function=GXcopy;
 val.graphics_exposures = false;
 val.line_style = LineOnOffDash;
 val.line_width = 0;
 thin_on_off_line_gc =
  XCreateGC(fl_display, fl_root, GCBackground
     | GCForeground | GCFunction | GCGraphicsExposures
     | GCLineWidth | GCLineStyle , &val);
 XFlush(fl_display);
 
 return thin_on_off_line_gc;
}


static
GC GetCopyGC()
{
 if (copy_gc) return copy_gc;
 XGCValues val;
 do_reverse_video(val);

 val.function=GXcopy;
 val.graphics_exposures = false;
 val.line_style = LineSolid;
 val.line_width = 0;
 copy_gc = XCreateGC(fl_display, fl_root, GCBackground
       | GCForeground | GCFunction | GCGraphicsExposures
       | GCLineWidth | GCLineStyle , &val);
 XFlush(fl_display);

 return copy_gc;
}


static
GC GetSelectGC()
{
 if (select_gc) return select_gc;
 XGCValues val;
 unsigned int a = BlackPixel(fl_display, DefaultScreen(fl_display));
 unsigned int b = WhitePixel(fl_display, DefaultScreen(fl_display)); 
 val.plane_mask = a^b;
 val.line_style = LineSolid;
 val.line_width = 2;
 val.graphics_exposures = false;
 val.function=GXinvert;
 select_gc = XCreateGC(fl_display, fl_root,
         GCFunction | GCGraphicsExposures | GCPlaneMask
          | GCLineWidth | GCLineStyle , &val);
 XFlush(fl_display);

 return select_gc; 
}


static
GC GetSelectionGC()
{
 if (selection_gc) return selection_gc;
 
 XGCValues val;

 if (!reverse_video) {
  val.foreground=BlackPixel(fl_display,
       DefaultScreen(fl_display));
  val.background=WhitePixel(fl_display,
       DefaultScreen(fl_display));
 } else {
  val.background=BlackPixel(fl_display,
       DefaultScreen(fl_display));
  val.foreground=WhitePixel(fl_display,
       DefaultScreen(fl_display));
 }
 
 val.function=GXcopy;
 val.graphics_exposures = false;
 if (!fast_selection && selection_color[0] != 0) {
  if (!setForegroundColor(selection_color, val)) {
   fast_selection = True;
   if (clear_gc) clear_gc = 0;
   lyxerr.print(" Will use FastSelection-method.\n");
  }
 }
 selection_gc = XCreateGC(fl_display, fl_root,
     GCBackground | GCForeground | GCFunction
     | GCGraphicsExposures, &val);

 return selection_gc;
}


static
GC GetLightedGC()
{
 if (lighted_gc) return lighted_gc;
 XGCValues val;
 if (reverse_video) {
  val.background=BlackPixel(fl_display, DefaultScreen(fl_display));
 } else {
  val.background=WhitePixel(fl_display, DefaultScreen(fl_display));
 }
 val.foreground=val.background;
 val.function=GXcopy;
 val.graphics_exposures = false;
 val.line_style = LineSolid;
 val.line_width = 0;
 setForegroundColor(lighted_color, val);
 lighted_gc = XCreateGC(fl_display, fl_root, GCBackground
          | GCForeground | GCFunction | GCGraphicsExposures
          | GCLineWidth | GCLineStyle , &val);
 XFlush(fl_display);

 return lighted_gc;
}


GC GetColorGC(LyXFont::FONT_COLOR color)
{
 if (color_gc[color]) return color_gc[color];
         
 XGCValues val;
 do_reverse_video(val);

 val.function=GXcopy;
 val.graphics_exposures = false;
 setForegroundColor(X11Color[color], val);
 val.line_width = 0;
 val.line_style = LineSolid;
 color_gc[color] = XCreateGC(fl_display, fl_root,
        GCBackground | GCForeground | GCFunction |
        GCGraphicsExposures | GCLineWidth |
        GCLineStyle , &val);
 XFlush(fl_display);

 return color_gc[color];
}


GC GetAccentGC(LyXFont const &f, int line_width)
{
 if (line_width>=10) line_width = 9;
 
 if (accent_gc[line_width]) return accent_gc[line_width];
 
 // Build this one from normal text GC, but change linewidth.
 XGCValues val;
 GC gc = f.getGC();
 XGetGCValues(fl_display, gc, GCBackground | GCForeground | 
       GCFunction | GCGraphicsExposures | GCLineWidth | 
       GCLineStyle | GCPlaneMask, &val);

 val.line_width = line_width;
 val.cap_style = CapRound;
 val.join_style = JoinRound;
 
 GC ac = XCreateGC(fl_display, fl_root, 
     GCBackground | GCForeground | GCFunction | 
     GCGraphicsExposures | GCLineWidth | 
     GCLineStyle | GCPlaneMask, &val);
 
 XFlush(fl_display);
 accent_gc[line_width] = ac;

 return accent_gc[line_width];
}


static
GC GetMinipageGC()
{
 if (minipage_gc) return minipage_gc;
        XGCValues val;
 do_reverse_video(val);

        val.function=GXcopy;
        val.graphics_exposures = false;
        val.line_style = LineOnOffDash;
        val.line_width = 0;
        setForegroundColor(fill_color, val);
        minipage_gc = XCreateGC(fl_display, fl_root,
                                GCBackground | GCForeground | GCFunction |
                                GCGraphicsExposures | GCLineWidth |
                                GCLineStyle , &val);
        XFlush(fl_display);

 return minipage_gc;
}


GC getGC(gc_type typ)
{
 GC gc = NULL;
 switch(typ) {
 case gc_clear:
  gc = GetClearGC();
  break;
 case gc_latex:
  gc = GetLatexGC();
  break;
 case gc_foot:
  gc = GetFootGC();
  break;
 case gc_new_line:
         gc = GetNewLineGC();
                break;
 case gc_math:
  gc = GetMathGC();
  break;
 case gc_math_frame:
  gc = GetMathFrameGC();
  break;
 case gc_fill:
  gc = GetFillGC();
  break;
 case gc_copy:
  gc = GetCopyGC();
  break;
 case gc_select:
  gc = GetSelectGC();
  break;
 case gc_on_off_line:
  gc = GetOnOffLineGC();
  break;
 case gc_thin_on_off_line:
  gc = GetThinOnOffLineGC();
  break;
 case gc_thick_line:
  gc = GetThickLineGC();
  break;
 case gc_lighted:
  gc = GetLightedGC();
  break;
 case gc_selection:
  gc = GetSelectionGC();
  break;
 case gc_minipage:
  gc = GetMinipageGC();
  break;
 case gc_note:
  gc = GetNoteGC();
  break;
 case gc_note_frame:
  gc = GetNoteFrameGC();
  break;
 }
 return gc;
}

¤ Dauer der Verarbeitung: 0.21 Sekunden  (vorverarbeitet)  ¤



Druckansicht
unsichere Verbindung
Druckansicht
sprechenden Kalenders

Eigene Datei ansehen




schauen Sie vor die Tür

Fenster


Die Firma ist wie angegeben erreichbar.

Die farbliche Syntaxdarstellung ist noch experimentell.


Bot Zugriff