예제 #1
0
void PhotoPreview::Redraw() {
	Glib::RefPtr<Gdk::Window> Window=get_window();
	if (Window)
		Window->invalidate_rect(Gdk::Rectangle(0,0,get_width(),get_height()),1);
}
예제 #2
0
int main(int argc, char* argv[]){
 
  char* action;
  Window window;
  int arg[5]={0};

  // Connexion à un serveur X
  display = XOpenDisplay(NULL);
  if(!display){
    printf("Can not open display.\n");
    exit(EXIT_FAILURE);
  }

  // Récupère la valeur par default des différentes variables.
  screen = DefaultScreen(display);
  gc = DefaultGC (display, screen);
  root = RootWindow (display, screen);
  // Détermine l'action à effectuer :
  // On vérifie que le 2er argument (autre que nom fichier) est un id de fenetre :

  if(argc>2 && ((!strncmp(argv[2],"0x",2) && strtoll(argv[2],NULL,16)) || strtoll(argv[2],NULL,10)) ){  

      action = argv[1];
      window = get_window(argv); 
      
      // Si 5 arguments, c'est soit un move, soit un resize:
      if (argc==3){ // 1 seul argument (ex: 0x32422 )
	if(!strcmp(action,"mapRaise"))
	  do_map_and_raise(window);
	else if(!strcmp(action,"map"))
	  do_map(window);
	else if(!strcmp(action,"raise"))
	  do_raise(window);
	else if(!strcmp(action,"destroy"))
	  do_destroy(window);
	else if(!strcmp(action,"focus"))
	  do_focus(window);
	else if(!strcmp(action,"minimize"))
	  do_minimize(window);
	else if(!strcmp(action,"set_desktop"))
	  set_desktop((int)strtoll(argv[2],NULL,10));
	else
	  fail();
      }
      else if(argc==4){ // 2 arguments (ex : 0x4242535 1 )
	if(!strcmp(action,"set_desktop_for_window")){
	  set_desktop(strtoll(argv[3],NULL,10));
	  set_desktop_for_window(window,strtoll(argv[3],NULL,10));
	}
	else if(!strcmp(action,"set_viewport"))
	  set_viewport((int)strtoll(argv[2],NULL,10),(int)strtoll(argv[3],NULL,10));
	else
	  fail();
      }
      else if(argc==5){ 

	arg[0]=(int)strtoll(argv[3],NULL,10);
	arg[1]=(int)strtoll(argv[4],NULL,10);
	if(!strcmp(action,"move"))
	  do_move(window, arg[0], arg[1]); 
	else if(!strcmp(action,"resize"))
	  do_resize(window,arg[0],arg[1]); 
	else
	  fail();
      }
      else if(argc==7){

	arg[0]=(int)strtoll(argv[3],NULL,10);
	arg[1]=(int)strtoll(argv[4],NULL,10);
	arg[2]=(int)strtoll(argv[5],NULL,10);
	arg[3]=(int)strtoll(argv[6],NULL,10);

	if(!strcmp(action,"moveResize"))
	  do_move_and_resize(window, arg[0], arg[1], arg[2], arg[3]); 
	else
	  fail();
      }
      else
	fail();
  }
  else
    fail();
  
  
  XCloseDisplay(display);
  return EXIT_SUCCESS;
  
}
예제 #3
0
static int perform_graphics_task(aroop_txt_t*msg, int*offset, int*cur_key, int*cur_type, int*cur_len, x11_window_t**gwin) {
	// check the task ..
	int cmd = msg_numeric_value(msg, offset, cur_type, cur_len);
	x11_window_t*win = *gwin;
	switch(cmd) {
	case ENUM_ROOPKOTHA_GRAPHICS_TASKS_DRAW_IMAGE:
		{
			SYNC_ASSERT(msg_next(msg, offset, cur_key, cur_type, cur_len) != -1);
			SYNC_ASSERT(*cur_key == ENUM_ROOPKOTHA_GUI_CORE_TASK_ARG);
			aroop_txt_t img_data;
			msg_binary_value(msg, offset, cur_type, cur_len, &img_data);
			unsigned int x,y,anc;
			msg_scan(msg, offset, cur_key, cur_type, cur_len, 3, &x, &y, &anc);
			break;
		}
	case ENUM_ROOPKOTHA_GRAPHICS_TASKS_DRAW_LINE:
		{
			unsigned int x1,x2,y1,y2;
			msg_scan(msg, offset, cur_key, cur_type, cur_len, 4, &x1, &y1, &x2, &y2);
	    		if(win) {
				XDrawLine (gcore.disp, win->w, win->gc, x1, y1, x2, y2);
			}
			break;
		}
	case ENUM_ROOPKOTHA_GRAPHICS_TASKS_DRAW_RECT:
		{
			unsigned int x,y,width,height;
			msg_scan(msg, offset, cur_key, cur_type, cur_len, 4, &x, &y, &width, &height);
	    		if(win) {
				XDrawRectangle (gcore.disp, win->w, win->gc, x, y, width, height);
			}
			break;
		}
	case ENUM_ROOPKOTHA_GRAPHICS_TASKS_DRAW_ROUND_RECT:
		{
			int x,y,width,height,arcWidth,arcHeight;
			msg_scan(msg, offset, cur_key, cur_type, cur_len, 6, &x, &y, &width, &height, &arcWidth, &arcHeight);
	    		if(win) {
				XDrawRectangle (gcore.disp, win->w,win->gc, x, y, width, height);
			}
			break;
		}
	case ENUM_ROOPKOTHA_GRAPHICS_TASKS_FILL_RECT:
		{
			unsigned int x,y,width,height;
			msg_scan(msg, offset, cur_key, cur_type, cur_len, 4, &x, &y, &width, &height);
	    		if(win) {
				XFillRectangle (gcore.disp, win->w,win->gc, x, y, width, height);
			}
			break;
		}
	case ENUM_ROOPKOTHA_GRAPHICS_TASKS_FILL_ROUND_RECT:
		{
			int x,y,width,height,arcWidth,arcHeight;
			msg_scan(msg, offset, cur_key, cur_type, cur_len, 6, &x, &y, &width, &height, &arcWidth, &arcHeight);
	    		if(win) {
				XFillRectangle (gcore.disp, win->w,win->gc, x, y, width, height);
			}
			break;
		}
	case ENUM_ROOPKOTHA_GRAPHICS_TASKS_FILL_TRIANGLE:
		{
			int x1,y1,x2,y2,x3,y3;
			msg_scan(msg, offset, cur_key, cur_type, cur_len, 6, &x1, &y1, &x2, &y2, &x3, &y3);
			// TODO draw line
			break;
		}
	case ENUM_ROOPKOTHA_GRAPHICS_TASKS_DRAW_STRING:
		{
			SYNC_ASSERT(msg_next(msg, offset, cur_key, cur_type, cur_len) != -1);
			SYNC_ASSERT(*cur_key == ENUM_ROOPKOTHA_GUI_CORE_TASK_ARG);
			aroop_txt_t content;
			msg_string_value(msg, offset, cur_type, cur_len, &content);
			int x,y,width,height,anc;
			msg_scan(msg, offset, cur_key, cur_type, cur_len, 5, &x, &y, &width, &height, &anc);
	    		if(!win) {
				break;
			}
			int xpos = x;
			if(anc & ENUM_ROOPKOTHA_GRAPHICS_ANCHOR_RIGHT) {
				xpos = x+width-5*content.len;
			}
			int ypos = y+10;
			if(anc & ENUM_ROOPKOTHA_GRAPHICS_ANCHOR_BOTTOM) {
				ypos = y+height;
			}
			XDrawString (gcore.disp, win->w,win->gc, xpos, ypos, aroop_txt_to_string(&content), content.len);
			break;
		}
	case ENUM_ROOPKOTHA_GRAPHICS_TASKS_SET_COLOR: // TODO abolish this task
		{
			SYNC_ASSERT(msg_next(msg, offset, cur_key, cur_type, cur_len) != -1);
			SYNC_ASSERT(*cur_key == ENUM_ROOPKOTHA_GUI_CORE_TASK_ARG);
			unsigned int rgb = msg_numeric_value(msg, offset, cur_type, cur_len);
	    		if(!win) {
				break;
			}
			Colormap colormap;
			colormap = DefaultColormap(gcore.disp, gcore.scrn);
			XColor rgbc;
#define RGBC rgbc
//#define RGBC gcore.rgbc
			unsigned char red = ((rgb & 0XFF0000)>>16) & 0xFF;
			unsigned char green = ((rgb & 0XFF00)>>8) & 0xFF;
			unsigned char blue = rgb & 0XFF;
			char spec[32];
			snprintf(spec, 32, "#%02x%02x%02x", red, green, blue);
			XParseColor (gcore.disp, colormap, spec, &RGBC);
			XAllocColor(gcore.disp, colormap, &RGBC);
			// TODO free color !
			XSetForeground (gcore.disp, win->gc, RGBC.pixel);
			break;
		}
	case ENUM_ROOPKOTHA_GRAPHICS_TASKS_SET_FONT: // TODO abolish this task
		{
			SYNC_ASSERT(msg_next(msg, offset, cur_key, cur_type, cur_len) != -1);
			SYNC_ASSERT(*cur_key == ENUM_ROOPKOTHA_GUI_CORE_TASK_ARG);
			int fontid = msg_numeric_value(msg, offset, cur_type, cur_len);
			// TODO set font
			break;
		}
	case ENUM_ROOPKOTHA_GRAPHICS_TASKS_START_LAYER:
		{
			int wid,layer;
			msg_scan(msg, offset, cur_key, cur_type, cur_len, 2, &wid, &layer);
			win = get_window(wid);
			*gwin = win;
			// save the layer
			aroop_txt_t*oldTasks = opp_indexed_list_get(&gcore.layers, layer);
			if(oldTasks != msg) {
				opp_indexed_list_set(&gcore.layers, layer, msg);
			}
			if(oldTasks) {
				aroop_object_unref(aroop_txt_t*,0,oldTasks);
			}
			break;
		}
	}
	return 0;
}
예제 #4
0
SANE_Status
sane_start (SANE_Handle handle)
{
  char *mode_str;
  Ricoh_Scanner *s = handle;
  SANE_Status status;
  struct ricoh_window_data wbuf;
  struct measurements_units_page mup;

  DBG (11, ">> sane_start\n");

  /* First make sure we have a current parameter set.  Some of the
     parameters will be overwritten below, but that's OK.  */
  status = sane_get_parameters (s, 0);
  if (status != SANE_STATUS_GOOD)
    return status;

  status = sanei_scsi_open (s->hw->sane.name, &s->fd, 0, 0);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "open of %s failed: %s\n",
           s->hw->sane.name, sane_strstatus (status));
      return (status);
    }

  mode_str = s->val[OPT_MODE].s;
  s->xres = s->val[OPT_X_RESOLUTION].w;
  s->yres = s->val[OPT_Y_RESOLUTION].w;
  s->ulx = s->val[OPT_TL_X].w;
  s->uly = s->val[OPT_TL_Y].w;
  s->width = s->val[OPT_BR_X].w - s->val[OPT_TL_X].w;
  s->length = s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w;
  s->brightness = s->val[OPT_BRIGHTNESS].w;
  s->contrast = s->val[OPT_CONTRAST].w;
  s->bpp = s->params.depth;
  if (strcmp (mode_str, SANE_VALUE_SCAN_MODE_LINEART) == 0) 
    {
      s->image_composition = RICOH_BINARY_MONOCHROME;
    }
  else if (strcmp (mode_str, SANE_VALUE_SCAN_MODE_HALFTONE) == 0)
    {
      s->image_composition = RICOH_DITHERED_MONOCHROME;
    }
  else if (strcmp (mode_str, SANE_VALUE_SCAN_MODE_GRAY) == 0)
    {
      s->image_composition = RICOH_GRAYSCALE;
    }

  memset (&wbuf, 0, sizeof (wbuf));
  _lto2b(sizeof(wbuf) - 8, wbuf.len);
  _lto2b(s->xres, wbuf.x_res);
  _lto2b(s->yres, wbuf.y_res);
  _lto4b(s->ulx, wbuf.x_org);
  _lto4b(s->uly, wbuf.y_org);
  _lto4b(s->width, wbuf.width);
  _lto4b(s->length, wbuf.length);

  wbuf.image_comp = s->image_composition;
  /* if you throw the MRIF bit the brighness control reverses too */
  /* so I reverse the reversal in software for symmetry's sake */
  if (wbuf.image_comp == RICOH_GRAYSCALE || wbuf.image_comp == RICOH_DITHERED_MONOCHROME) 
    {
      if (wbuf.image_comp == RICOH_GRAYSCALE) 
	wbuf.mrif_filtering_gamma_id = (SANE_Byte) 0x90;
      if (wbuf.image_comp == RICOH_DITHERED_MONOCHROME) 
	wbuf.mrif_filtering_gamma_id = (SANE_Byte) 0x10;
      wbuf.brightness = 256 - (SANE_Byte) s->brightness;
      if (is50)
        wbuf.contrast = (SANE_Byte) s->contrast;
      else
        wbuf.contrast = 256 - (SANE_Byte) s->contrast;
    }
  else /* wbuf.image_comp == RICOH_BINARY_MONOCHROME */
    {
      wbuf.mrif_filtering_gamma_id = (SANE_Byte) 0x00;
      wbuf.brightness = (SANE_Byte) s->brightness;
      wbuf.contrast = (SANE_Byte) s->contrast;
    }

  wbuf.threshold = 0;
  wbuf.bits_per_pixel = s->bpp;

  wbuf.halftone_pattern[0] = 2;
  wbuf.halftone_pattern[1] = 0;
  wbuf.pad_type = 3;
  wbuf.bit_ordering[0] = 0;
  wbuf.bit_ordering[1] = 3;

  DBG (5, "xres=%d\n", _2btol(wbuf.x_res));
  DBG (5, "yres=%d\n", _2btol(wbuf.y_res));
  DBG (5, "ulx=%d\n", _4btol(wbuf.x_org));
  DBG (5, "uly=%d\n", _4btol(wbuf.y_org));
  DBG (5, "width=%d\n", _4btol(wbuf.width));
  DBG (5, "length=%d\n", _4btol(wbuf.length));
  DBG (5, "image_comp=%d\n", wbuf.image_comp);

  DBG (11, "sane_start: sending SET WINDOW\n");
  status = set_window (s->fd, &wbuf);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "SET WINDOW failed: %s\n", sane_strstatus (status));
      return (status);
    }

  DBG (11, "sane_start: sending GET WINDOW\n");
  memset (&wbuf, 0, sizeof (wbuf));
  status = get_window (s->fd, &wbuf);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "GET WINDOW failed: %s\n", sane_strstatus (status));
      return (status); 
    }
  DBG (5, "xres=%d\n", _2btol(wbuf.x_res));
  DBG (5, "yres=%d\n", _2btol(wbuf.y_res));
  DBG (5, "ulx=%d\n", _4btol(wbuf.x_org));
  DBG (5, "uly=%d\n", _4btol(wbuf.y_org));
  DBG (5, "width=%d\n", _4btol(wbuf.width));
  DBG (5, "length=%d\n", _4btol(wbuf.length));
  DBG (5, "image_comp=%d\n", wbuf.image_comp);

  DBG (11, "sane_start: sending MODE SELECT\n");
  memset (&mup, 0, sizeof (mup));
  mup.page_code = MEASUREMENTS_PAGE;
  mup.parameter_length = 0x06;
  mup.bmu = INCHES;
  mup.mud[0] = (DEFAULT_MUD >> 8) & 0xff;
  mup.mud[1] = (DEFAULT_MUD & 0xff);

  status = mode_select (s->fd, (struct mode_pages *) &mup);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "attach: MODE_SELECT failed\n");
      return (SANE_STATUS_INVAL);
    }

  status = trigger_scan (s->fd);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "start of scan failed: %s\n", sane_strstatus (status));
      return (status);
    }

  /* Wait for scanner to become ready to transmit data */
  status = ricoh_wait_ready (s);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "GET DATA STATUS failed: %s\n", sane_strstatus (status));
      return (status);
    } 

  s->bytes_to_read = s->params.bytes_per_line * s->params.lines;

  DBG (1, "%d pixels per line, %d bytes, %d lines high, total %lu bytes, "
       "dpi=%d\n", s->params.pixels_per_line, s->params.bytes_per_line,
       s->params.lines, (u_long) s->bytes_to_read, s->val[OPT_Y_RESOLUTION].w);
 
  s->scanning = SANE_TRUE;

  DBG (11, "<< sane_start\n"); 
  return (SANE_STATUS_GOOD); 
}
예제 #5
0
 void BugzillaNoteAddin::on_note_opened()
 {
   get_window()->editor()->signal_drag_data_received().connect(
     sigc::mem_fun(*this, &BugzillaNoteAddin::on_drag_data_received), false);
 }
예제 #6
0
bool knob::on_expose_event(GdkEventExpose* event)
{

  // This is where we draw on the window
  Glib::RefPtr<Gdk::Window> window = get_window();
  if(window)
  {
    Gtk::Allocation allocation = get_allocation();
    const int width = allocation.get_width();
    const int height = allocation.get_height() - (allocation.get_height()/3);
    const int height_offset = allocation.get_height()/6;

    // coordinates for the center of the window
    int xc, yc;
    xc = width / 2;
    yc = height / 2;

    Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
    cr->set_line_width(6.0);

    // clip to the area indicated by the expose event so that we only redraw
    // the portion of the window that needs to be redrawn
    cr->rectangle(event->area.x, event->area.y,
            event->area.width, event->area.height);
    cr->clip();
    
    // background grad

	Cairo::RefPtr<Cairo::LinearGradient> back_grad =
	Cairo::LinearGradient::create( 0,0,0,allocation.get_height() );

	switch (pos_mode)
	{
		case 0:
	        back_grad->add_color_stop_rgba(0,top_colour.get_red_p(),top_colour.get_green_p(),top_colour.get_blue_p(),1);
	        back_grad->add_color_stop_rgba(1,bottom_colour.get_red_p(),bottom_colour.get_green_p(),bottom_colour.get_blue_p(),1);
		break;

		case 1:
	        back_grad->add_color_stop_rgba(0,top_colour.get_red_p(),top_colour.get_green_p(),top_colour.get_blue_p(),1);
	        back_grad->add_color_stop_rgba(1,
			(bottom_colour.get_red_p() + top_colour.get_red_p())/2,
			(bottom_colour.get_green_p() + top_colour.get_green_p())/2,
			(bottom_colour.get_blue_p() + top_colour.get_blue_p())/2,
			1);
		break;

		case 2:
	        back_grad->add_color_stop_rgba(0,
			(bottom_colour.get_red_p() + top_colour.get_red_p())/2,
			(bottom_colour.get_green_p() + top_colour.get_green_p())/2,
			(bottom_colour.get_blue_p() + top_colour.get_blue_p())/2,
			1);
	        back_grad->add_color_stop_rgba(1,bottom_colour.get_red_p(),bottom_colour.get_green_p(),bottom_colour.get_blue_p(),1);
		break;
	}

	// fill background
	if (rounded<5)
	{
		rounded_rectangle(cr,rounded, grad_top_colour,
			grad_bottom_colour, event->area.x, event->area.y,
			event->area.width, event->area.height,pos_mode,
			top_colour.to_string(),bottom_colour.to_string() );
	}
	else 
	{
		cr->rectangle(event->area.x, event->area.y,
			event->area.width, event->area.height);
	}


	cr->set_source(back_grad);
	cr->fill();
    
    // ------------------------------------------------------------------

	float cos_x =  (allocation.get_width()/5) * (cos(((((1-knob_value)*0.75)-0.3)*2) * M_PI));
	float sin_y =  (allocation.get_width()/5) * (sin(((((1-knob_value)*0.75)-0.3)*2) * M_PI));

     Cairo::RefPtr<Cairo::RadialGradient> grad1 =
Cairo::RadialGradient::create( (allocation.get_width()/2) + sin_y, (allocation.get_height()/2) + cos_x, 0, (allocation.get_width()/2) , (allocation.get_height()/2) ,(allocation.get_width()/2.5));
        grad1->add_color_stop_rgba(0,0.4,0.4,0.4,1);
        grad1->add_color_stop_rgba(0.5,0.2,0.2,0.2,1);
        grad1->add_color_stop_rgba(0.8,0.17,0.17,0.17,1);
        grad1->add_color_stop_rgba(1.0,0.0,0.0,0.0,1);

	cos_x =  (allocation.get_width()/5) * (cos((((knob_value*0.75)-0.61)*2) * M_PI));
	sin_y =  (allocation.get_width()/5) * (sin((((knob_value*0.75)-0.61)*2) * M_PI));

	cr->set_source(grad1);
	cr->arc(allocation.get_width()/2, allocation.get_height()/2, (allocation.get_width()/2.5), 0.0, 2 * M_PI);
	cr->fill();
	cr->set_source_rgb(0.0, 0.0, 0.0);
	cr->arc((allocation.get_width()/2) +cos_x, (allocation.get_height()/2)+sin_y, (allocation.get_width()/16), 0.0, 2 * M_PI);
	cr->fill();

    // draw text label
    cr->select_font_face("Bitstream Vera Sans", Cairo::FONT_SLANT_NORMAL,
     Cairo::FONT_WEIGHT_NORMAL);
    cr->set_font_size(width/4.5);
    cr->set_source_rgba(0.9,0.9,0.9,0.8);
    Cairo::FontOptions font_options;
    font_options.set_hint_style(Cairo::HINT_STYLE_NONE);
    font_options.set_hint_metrics(Cairo::HINT_METRICS_OFF);
    font_options.set_antialias(Cairo::ANTIALIAS_GRAY);
	
    int x_font_centre = (width/2) - ((width/5) * (label.length()/3.5));

    cr->set_font_options(font_options);
    cr->move_to(x_font_centre,height/3.5);
    cr->show_text(label);
    cr->move_to(x_font_centre,allocation.get_height()  - (height_offset/3) );

    ostringstream slider_value;
    slider_value.str("");

    if (invert)
    {
	slider_value << max - value;
    }
    else
    {
    	slider_value << value;
    }

    slider_value.str(slider_value.str().substr(0,5));

    x_font_centre = (width/2) - ((width/5) * (slider_value.str().length()/3.5));
    cr->move_to(x_font_centre,allocation.get_height() - (height_offset/1.5) );

    cr->show_text(slider_value.str());

  }

  return true;
}
예제 #7
0
static VALUE rbncurs_c_set_menu_sub(VALUE rb_menu, VALUE rb_sub)
{
  MENU *menu = get_menu(rb_menu);
  WINDOW *win = get_window(rb_sub);
  return INT2NUM(set_menu_sub(menu, win));
}
예제 #8
0
파일: chooser.cpp 프로젝트: utsushi/utsushi
void
chooser::create_device (const std::set<scanner::info>& devices,
                        const std::string& udi)
{
  std::set<scanner::info>::const_iterator it = devices.begin ();
  while (devices.end () != it && udi != it->udi ()) {
    ++it;
  }
  if (devices.end () != it) {

    Glib::RefPtr< Gdk::Window > window = get_window ();

    if (window)
      {
        window->set_cursor (Gdk::Cursor (Gdk::WATCH));
        Gdk::flush ();
      }

    scanner::ptr ptr;
    std::string  why;
    try
      {
        // FIXME This is a bit clunky but scanner creation may be time
        //       consuming and cannot be put in a separate thread if
        //       the scanner object is run via process separation.
        //       The child process would exit at thread end.

        while (Gtk::Main::events_pending ())
          Gtk::Main::iteration ();

        ptr = scanner::create (*it);
      }
    catch (const std::exception& e)
      {
        why = e.what ();
      }
    catch (...)
      {
        // FIXME set a why we failed to create a device
      }

    if (window)
      {
        window->set_cursor ();
      }

    if (ptr)
      {
        cache_ = get_active ();
        set_tooltip_text (it->udi ());
        signal_device_changed_.emit (ptr);
      }
    else
      {
        const std::string& name = get_active ()->get_value (cols_->name);
        const std::string& udi  = get_active ()->get_value (cols_->udi);

        inhibit_callback_ = true;
        if (cache_) set_active (cache_);
        inhibit_callback_ = false;

        BOOST_THROW_EXCEPTION
          (std::runtime_error
           ((format (SEC_("Cannot access %1%\n(%2%)\n%3%"))
             % name
             % udi
             % _(why)
             ).str ()));
      }
  }
}
void OSGDrawingArea::invalidate ()
{
    Gdk::Rectangle lRect = get_allocation ();
    get_window ()->invalidate_rect (Gdk::Rectangle (0, 0, lRect.get_width (), lRect.get_height ()),
        false);
}
예제 #10
0
bool DimRegionChooser::on_expose_event(GdkEventExpose* event)
{
    if (!region) return true;

    // This is where we draw on the window
    Glib::RefPtr<Gdk::Window> window = get_window();
    Glib::RefPtr<Pango::Context> context = get_pango_context();

    Glib::RefPtr<Pango::Layout> layout = Pango::Layout::create(context);

    window->clear();

    // draw labels on the left (reflecting the dimension type)
    int y = 0;
    double maxwidth = 0;
    for (int i = 0 ; i < region->Dimensions ; i++) {
        int nbZones = region->pDimensionDefinitions[i].zones;
        if (nbZones) {
            const char* dstr;
            char dstrbuf[10];
            switch (region->pDimensionDefinitions[i].dimension) {
            case gig::dimension_none: dstr="none"; break;
            case gig::dimension_samplechannel: dstr="samplechannel"; break;
            case gig::dimension_layer: dstr="layer"; break;
            case gig::dimension_velocity: dstr="velocity"; break;
            case gig::dimension_channelaftertouch: dstr="channelaftertouch"; break;
            case gig::dimension_releasetrigger: dstr="releasetrigger"; break;
            case gig::dimension_keyboard: dstr="keyboard"; break;
            case gig::dimension_roundrobin: dstr="roundrobin"; break;
            case gig::dimension_random: dstr="random"; break;
            case gig::dimension_smartmidi: dstr="smartmidi"; break;
            case gig::dimension_roundrobinkeyboard: dstr="roundrobinkeyboard"; break;
            case gig::dimension_modwheel: dstr="modwheel"; break;
            case gig::dimension_breath: dstr="breath"; break;
            case gig::dimension_foot: dstr="foot"; break;
            case gig::dimension_portamentotime: dstr="portamentotime"; break;
            case gig::dimension_effect1: dstr="effect1"; break;
            case gig::dimension_effect2: dstr="effect2"; break;
            case gig::dimension_genpurpose1: dstr="genpurpose1"; break;
            case gig::dimension_genpurpose2: dstr="genpurpose2"; break;
            case gig::dimension_genpurpose3: dstr="genpurpose3"; break;
            case gig::dimension_genpurpose4: dstr="genpurpose4"; break;
            case gig::dimension_sustainpedal: dstr="sustainpedal"; break;
            case gig::dimension_portamento: dstr="portamento"; break;
            case gig::dimension_sostenutopedal: dstr="sostenutopedal"; break;
            case gig::dimension_softpedal: dstr="softpedal"; break;
            case gig::dimension_genpurpose5: dstr="genpurpose5"; break;
            case gig::dimension_genpurpose6: dstr="genpurpose6"; break;
            case gig::dimension_genpurpose7: dstr="genpurpose7"; break;
            case gig::dimension_genpurpose8: dstr="genpurpose8"; break;
            case gig::dimension_effect1depth: dstr="effect1depth"; break;
            case gig::dimension_effect2depth: dstr="effect2depth"; break;
            case gig::dimension_effect3depth: dstr="effect3depth"; break;
            case gig::dimension_effect4depth: dstr="effect4depth"; break;
            case gig::dimension_effect5depth: dstr="effect5depth"; break;
            default:
                sprintf(dstrbuf, "%d",
                        region->pDimensionDefinitions[i].dimension);
                dstr = dstrbuf;
                break;
            }
            layout->set_text(dstr);

            Pango::Rectangle rectangle = layout->get_logical_extents();
            double text_w = double(rectangle.get_width()) / Pango::SCALE;
            if (text_w > maxwidth) maxwidth = text_w;
            double text_h = double(rectangle.get_height()) / Pango::SCALE;
            Glib::RefPtr<const Gdk::GC> fg = get_style()->get_fg_gc(get_state());
            window->draw_layout(fg, 4, int(y + (h - text_h) / 2 + 0.5), layout);

        }
        y += h;
    }

    // draw dimensions' zones areas
    y = 0;
    int bitpos = 0;
    label_width = int(maxwidth + 10);
    for (int i = 0 ; i < region->Dimensions ; i++) {
        int nbZones = region->pDimensionDefinitions[i].zones;
        if (nbZones) {
            // draw focus rectangle around dimension's label and zones
            if (has_focus() && focus_line == i) {
                Gdk::Rectangle farea(0, y, 150, 20);
                get_style()->paint_focus(window, get_state(), farea, *this, "",
                                         0, y, label_width, 20);
            }

            Glib::RefPtr<const Gdk::GC> black = get_style()->get_black_gc();
            // draw top and bottom lines of dimension's zones
            window->draw_line(black, label_width, y, w - 1, y);
            window->draw_line(black, w - 1, y + h - 1, label_width, y + h - 1);
            // erase whole dimension's zones area
            window->draw_rectangle(get_style()->get_white_gc(), true,
                                   label_width + 1, y + 1, (w - label_width - 2), h - 2);

            int c = 0;
            if (dimregno >= 0) {
                int mask = ~(((1 << region->pDimensionDefinitions[i].bits) - 1) << bitpos);
                c = dimregno & mask; // mask away this dimension
            }
            bool customsplits =
                ((region->pDimensionDefinitions[i].split_type == gig::split_type_normal &&
                 region->pDimensionRegions[c]->DimensionUpperLimits[i]) ||
                (region->pDimensionDefinitions[i].dimension == gig::dimension_velocity &&
                 region->pDimensionRegions[c]->VelocityUpperLimit));

            // draw dimension's zone borders
            if (customsplits) {
                window->draw_line(black, label_width, y + 1, label_width, y + h - 2);
                for (int j = 0 ; j < nbZones ; j++) {
                    gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
                    int upperLimit = d->DimensionUpperLimits[i];
                    if (!upperLimit) upperLimit = d->VelocityUpperLimit;
                    int v = upperLimit + 1;
                    int x = int((w - label_width - 1) * v / 128.0 + 0.5);
                    window->draw_line(black, label_width + x, y + 1, label_width + x, y + h - 2);
                }
            } else {
                for (int j = 0 ; j <= nbZones ; j++) {
                    int x = int((w - label_width - 1) * j / double(nbZones) + 0.5);
                    window->draw_line(black, label_width + x, y + 1, label_width + x, y + h - 2);
                }
            }

            // draw fill for currently selected zone
            if (dimregno >= 0) {
                gc->set_foreground(red);
                int dr = (dimregno >> bitpos) & ((1 << region->pDimensionDefinitions[i].bits) - 1);
                if (customsplits) {
                    int x1 = 0;
                    for (int j = 0 ; j < nbZones ; j++) {
                        gig::DimensionRegion *d = region->pDimensionRegions[c + (j << bitpos)];
                        int upperLimit = d->DimensionUpperLimits[i];
                        if (!upperLimit) upperLimit = d->VelocityUpperLimit;
                        int v = upperLimit + 1;
                        int x2 = int((w - label_width - 1) * v / 128.0 + 0.5);
                        if (j == dr && x1 < x2) {
                            window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,
                                                   (x2 - x1) - 1, h - 2);
                            break;
                        }
                        x1 = x2;
                    }
                } else {
                    if (dr < nbZones) {
                        int x1 = int((w - label_width - 1) * dr / double(nbZones) + 0.5);
                        int x2 = int((w - label_width - 1) * (dr + 1) / double(nbZones) + 0.5);
                        window->draw_rectangle(gc, true, label_width + x1 + 1, y + 1,
                                               (x2 - x1) - 1, h - 2);
                    }
                }
            }

            y += h;
        }
        bitpos += region->pDimensionDefinitions[i].bits;
    }
예제 #11
0
MPI_Win _XMP_mpi_coarray_get_window(const _XMP_coarray_t *desc, bool is_acc)
{
  return get_window(desc, is_acc);
}
예제 #12
0
// this drags the image around
// big thanks to Ramax Lo for fixing this!!
bool CPagePreview::on_button1_pressed_motion(GdkEventMotion *event)
	{
	// get the cairo context amd allocation
	Gtk::Allocation allocation = get_allocation();
	const int width = allocation.get_width();
	const int height = allocation.get_height();		
	
	static int x,y;
	get_pointer(x, y);
	
#ifdef DEBUG
std::cout << "PAGE_PREVIEW::PRESSED_MOTION: x\ty :  " << x << '\t' << y << std::endl;
#endif // DEBUG		
	
	if(ImagePixbuf->get_width() < page_width-lmargin-rmargin )
		{
		if( (xpos + (x - dragoldx)) >= uleft.x  &&
			(xpos + (x - dragoldx)) <=
			( lright.x - ImagePixbuf->get_width() ) )
			{
			xpos = xpos + (x - dragoldx);
			dragoldx = x;
			}
		//snap to end
		else if( (xpos + (x - dragoldx)) < uleft.x	)
			{
			xpos = uleft.x;
			dragoldx = x;
			}
		else if( (xpos + (x - dragoldx)) >
			( lright.x - ImagePixbuf->get_width() ) )
			{
			xpos = lright.x - ImagePixbuf->get_width();
			dragoldx = x;
			}
		}
	
	if(ImagePixbuf->get_height() < page_height-lmargin-rmargin )
		{
		if( (ypos + (y - dragoldy)) >= uleft.y  &&
			(ypos + (y - dragoldy)) <=
			( lright.y - ImagePixbuf->get_height() ) )
			{
			ypos = ypos + (y - dragoldy);
			dragoldy = y;
			}
		//snap to end
		else if( (ypos + (y - dragoldy)) < uleft.y	)
			{
			ypos = uleft.y;
			dragoldy = y;
			}
		else if( (ypos + (y - dragoldy)) >
			( lright.y - ImagePixbuf->get_height() ) )
			{
			ypos = lright.y - ImagePixbuf->get_height();
			dragoldy = y;
			}
		}	
	
	// force redraw	
	Glib::RefPtr<Gdk::Window> window = get_window();
	if (window)
		{
		Gdk::Rectangle r(0, 0, get_allocation().get_width(),
				get_allocation().get_height());
		window->invalidate_rect(r, false);
		}	
	return true;	
	}		
예제 #13
0
bool CPagePreview::on_expose_event(GdkEventExpose *event)
	{			
	Glib::RefPtr<Gdk::Window> window = get_window();
	if(window)
		{
		// get the cairo context amd allocation
		Cairo::RefPtr<Cairo::Context> cr = window->create_cairo_context();
		Gtk::Allocation allocation = get_allocation();
		const int width = allocation.get_width();
		const int height = allocation.get_height();
		
		// coordinates for the center of the window
		int xc, yc;
		xc = width / 2;
		yc = height / 2;

		
		// clip to the area indicated by the expose event so that we only redraw
		// the portion of the window that needs to be redrawn
		cr->rectangle(event->area.x, event->area.y,
				event->area.width, event->area.height);
		cr->clip();
		
		// draw a neat shadow
		cr->set_source_rgba(0.0,0.0,0.0,0.4);
		cr->begin_new_path();
		cr->move_to( xborder+offset,yborder+offset );
		cr->line_to( width-xborder+offset,yborder+offset );
		cr->line_to( width-xborder+offset,height-yborder+offset );
		cr->line_to( xborder+offset,height-yborder+offset );
		cr->close_path();
		cr->fill();

		// draw the page outline
		cr->set_source_rgb(0.0,0.0,0.0); // black
		cr->set_line_width( 2.0 );
		cr->begin_new_path();
		cr->move_to( xborder-offset,yborder-offset );
		cr->line_to( width-xborder-offset,yborder-offset );
		cr->line_to( width-xborder-offset,height-yborder-offset );
		cr->line_to( xborder-offset,height-yborder-offset );
		cr->close_path();
		cr->stroke_preserve();
		
		// fill the page with white
		cr->save();
		cr->set_source_rgb(1.0,1.0,1.0); // white
		cr->fill_preserve();
		cr->restore();
		
		// draw the page margin
		cr->set_source_rgb( 0.8,0.8,0.8 ); // light grey
		cr->set_line_width( 1.0 );
		cr->begin_new_path();
		cr->move_to( uleft.x, uleft.y );
		cr->line_to( lright.x, uleft.y );
		cr->line_to( lright.x, lright.y );
		cr->line_to( uleft.x, lright.y );
		cr->close_path();
		cr->stroke();

		// and the image preview
		ImagePixbuf->render_to_drawable( get_window(),
									get_style()->get_black_gc(),
									0,
									0,
									xpos,
									ypos,
									ImagePixbuf->get_width(), //image->get_width(),
									ImagePixbuf->get_height(), //image->get_height(),
									Gdk::RGB_DITHER_NONE,0,0 ); // */
									
		return true;
		}
	}
예제 #14
0
bool PhotoPreview::on_draw(const Cairo::RefPtr<Cairo::Context>& cr) {
	if (!Image)
		return false;

	int Width,Height;
	Gtk::Allocation Allocation = get_allocation();
	Width=Allocation.get_width();
	Height=Allocation.get_height();

	if (Width<=1 || Height<=1)
		return false;

	/* Scale the photo */
	Glib::RefPtr<Gdk::Pixbuf> Scaled;

	/* Preserve aspect ratio */
	double ImageAspectRatio,PreviewAspectRatio;
	PreviewAspectRatio=(float)Width/Height;
	ImageAspectRatio=(float)Image->get_width()/Image->get_height();
	if (ImageAspectRatio<PreviewAspectRatio) {
		Width=Height*ImageAspectRatio;
	} else {
		Height=Width/ImageAspectRatio;
	}

	Scaled=Image->scale_simple(
		Width,
		Height,
		Gdk::INTERP_BILINEAR);

	if (Cfg->GetFlipPreview())
		Scaled=Scaled->flip();

	Gdk::Cairo::set_source_pixbuf(cr, Scaled,
		(Allocation.get_width()/2)-(Scaled->get_width()/2),
		(Allocation.get_height()/2)-(Scaled->get_height()/2)
		);
	cr->paint();

	double TimeLeft=Util::TimeDiff(&PhotoTime,NULL);
	double MinDim=get_width();
	if (get_height()<MinDim)
		MinDim=get_height();

	if (Overlay.length()==0 && TimeLeft>0) {
		double TotalTime=Cfg->GetCountdownCount()*(Cfg->GetCountdownTimeout()/1000.0);
		unsigned int Whole=floor(Cfg->GetCountdownCount()*TimeLeft/TotalTime);
		float Frac=(Cfg->GetCountdownCount()*TimeLeft/TotalTime)-Whole;

		Cairo::RefPtr<Cairo::Context> Context = get_window()->create_cairo_context();

		Context->set_source_rgba(1.0, 1.0, 1.0,0.5);
		Context->translate(get_width()/2.0,get_height()/2.0);

		/* Draw the fractional portion of the countdown */
		Context->save();
		Context->rotate(M_PI/2.0);
		Context->arc(0.0,0.0,MinDim/4.0,0,Frac*2*M_PI);
		Context->fill();
		Context->restore();

		/* Draw the Whole portion of the countdown */
		Context->save();
		Context->set_font_size(MinDim/2.0);
		char StrBuf[1024];
		snprintf(StrBuf,sizeof(StrBuf),"%d",Whole+1);
		Cairo::TextExtents Extents;
		Context->get_text_extents(StrBuf,Extents);
		Context->translate(-Extents.width/2.0,Extents.height/2.0);

		Context->show_text(StrBuf);
		Context->stroke();
		Context->restore();
	}

	if (Overlay.length()) {
		Cairo::RefPtr<Cairo::Context> Context = get_window()->create_cairo_context();
		Context->set_source_rgba(1.0, 1.0, 1.0,0.5);
		Context->translate(get_width()/2.0,get_height()/2.0);

		Context->save();
		Context->set_font_size(MinDim/2.0);
		Cairo::TextExtents Extents;
		Context->get_text_extents(Overlay,Extents);
		Context->translate(-Extents.width/2.0,Extents.height/2.0);

		Context->show_text(Overlay);
		Context->stroke();
		Context->restore();
	}

	return true;
}
예제 #15
0
void Gui::draw(Piece *piece) {
	// The spritesheet is ordered to correlate with the Piece::Color and Piece::Type enums, so drawing from it is rather convenient.
	spritesheet->render_to_drawable(get_window(), get_style()->get_black_gc(), piece->type * TileSize, piece->color * TileSize,
		Position::File(piece->pos) * TileSize, (NUM_RANKS - 1 - Position::Rank(piece->pos)) * TileSize, TileSize, TileSize,
		Gdk::RGB_DITHER_NONE, 0, 0);
}
예제 #16
0
void LogoScene::goinit(){
    get_window()->changeScene(SceneType::INIT);
}
예제 #17
0
void knob::draw_slider(int x, int y)
{

	
	if (drag==false && max>1)
	{
		if (y > get_allocation().get_height()/2 && value > min) { value -= 1; }
		if (y < get_allocation().get_height()/2 && value < max) { value += 1; }
	}

	if (drag==false && max==1)
	{
		if (y > get_allocation().get_height()/2 && value > min) { value -= 0.001; }
		if (y < get_allocation().get_height()/2 && value < max) { value += 0.001; }
	}


	float width = get_allocation().get_width();
	float height = (get_allocation().get_height() / 1.5);

	if (drag==true)
	{
		// converty mouse y to knob value
		y-=(get_allocation().get_height()/6);
		knob_value = (height-y)/height;	

		if (knob_value < 0) { knob_value = 0; }
		if (knob_value > 1) { knob_value = 1; }

		if (max > min)
		{
			value =  min + (knob_value*(max-min));
	    	}
	
		if (max <= min)
		{
			value =  max + ((1-knob_value)*(min-max));
	    	}

	}	


	if (snap)
	{
		value = int(value);
		set_value(value);
	}



	// which port to write to, check your .ttl file for the index of
	// each port
   
	// here we use the LV2UI_Controller and LV2UI_write_function "things"
	// to write some data to a port
	if (invert)
	{
		float inverted_value = max - value;
		write_function( controller, port_number, sizeof(float), 0, (const void*)&inverted_value);
	}
	else
	{
		write_function( controller, port_number, sizeof(float), 0, (const void*)&value);
	}

	// ask GTK to redraw when it suits
	Glib::RefPtr<Gdk::Window> win = get_window();
	if (win)
	{
		Gdk::Rectangle r(0,0,get_allocation().get_width(), get_allocation().get_height() );
		win->invalidate_rect(r, false);
	}
}
예제 #18
0
파일: callbacks.c 프로젝트: iolo/liteamp
void on_add_location_activate(GtkAction * action, gpointer user_data)
{
    LocationDialog *dialog = location_dialog_new(get_window(app));
    location_dialog_show(dialog, "");
}
예제 #19
0
void tunit_preview_pane::profile_button_callback()
{
	if(get_window()) {
		help::show_unit_help((*get_window()).video(), current_type_);
	}
}
예제 #20
0
파일: callbacks.c 프로젝트: iolo/liteamp
void on_add_playlist_activate(GtkAction * action, gpointer user_data)
{
    PlaylistDialog *dialog;
    dialog = playlist_dialog_new(get_window(app));
    playlist_dialog_show(dialog, NULL);
}
예제 #21
0
static SANE_Status
attach (const char *devnam, Ricoh_Device ** devp)
{
  SANE_Status status;
  Ricoh_Device *dev;

  int fd;
  struct inquiry_data ibuf;
  struct measurements_units_page mup;
  struct ricoh_window_data wbuf;
  size_t buf_size;
  char *str;
  DBG (11, ">> attach\n");

  for (dev = first_dev; dev; dev = dev->next)
    {
      if (strcmp (dev->sane.name, devnam) == 0)
        {
          if (devp)
            *devp = dev;
          return (SANE_STATUS_GOOD);
        }
    }

  DBG (3, "attach: opening %s\n", devnam);
  status = sanei_scsi_open (devnam, &fd, NULL, NULL);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "attach: open failed: %s\n", sane_strstatus (status));
      return (status);
    }

  DBG (3, "attach: sending INQUIRY\n");
  memset (&ibuf, 0, sizeof (ibuf));
  buf_size = sizeof(ibuf);
  status = inquiry (fd, &ibuf, &buf_size);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "attach: inquiry failed: %s\n", sane_strstatus (status));
      sanei_scsi_close (fd);
      return (status);
    }

  if (ibuf.devtype != 6
      || strncmp ((char *)ibuf.vendor, "RICOH", 5) != 0
      || (strncmp ((char *)ibuf.product, "IS50", 4) != 0
	  && strncmp ((char *)ibuf.product, "IS60", 4) != 0))
    {
      DBG (1, "attach: device doesn't look like the Ricoh scanner I know\n");
      sanei_scsi_close (fd);
      return (SANE_STATUS_INVAL);
    }
  is50 = (strncmp ((char *)ibuf.product, "IS50", 4) == 0);

  DBG (3, "attach: sending TEST_UNIT_READY\n");
  status = test_unit_ready (fd);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "attach: test unit ready failed (%s)\n",
           sane_strstatus (status));
      sanei_scsi_close (fd);
      return (status);
    }

  DBG (3, "attach: sending OBJECT POSITION\n");
  status = object_position (fd);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "attach: OBJECT POSTITION failed\n");
      sanei_scsi_close (fd);
      return (SANE_STATUS_INVAL);
    }

  memset (&mup, 0, sizeof (mup));
  mup.page_code = MEASUREMENTS_PAGE;
  mup.parameter_length = 0x06;
  mup.bmu = INCHES;
  mup.mud[0] = (DEFAULT_MUD >> 8) & 0xff;
  mup.mud[1] = (DEFAULT_MUD & 0xff);

#if 0
  DBG (3, "attach: sending MODE SELECT\n");
  status = mode_select (fd, (struct mode_pages *) &mup);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "attach: MODE_SELECT failed\n");
      sanei_scsi_close (fd);
      return (SANE_STATUS_INVAL);
    } 
#endif

#if 0
  DBG (3, "attach: sending MODE SENSE\n");
  memset (&mup, 0, sizeof (mup));
  status = mode_sense (fd, (struct mode_pages *) &mup, PC_CURRENT | MEASUREMENTS_PAGE);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "attach: MODE_SENSE failed\n");
      sanei_scsi_close (fd);
      return (SANE_STATUS_INVAL);
    }
#endif

  DBG (3, "attach: sending GET WINDOW\n");
  memset (&wbuf, 0, sizeof (wbuf));
  status = get_window (fd, &wbuf);
  if (status != SANE_STATUS_GOOD)
    {
      DBG (1, "attach: GET_WINDOW failed %d\n", status);
      sanei_scsi_close (fd);
      DBG (11, "<< attach\n");
      return (SANE_STATUS_INVAL);
    }

  sanei_scsi_close (fd);

  dev = malloc (sizeof (*dev));
  if (!dev)
    return (SANE_STATUS_NO_MEM);
  memset (dev, 0, sizeof (*dev));

  dev->sane.name = strdup (devnam);
  dev->sane.vendor = "RICOH";
  str = malloc (16 + 1);
  memset (str, 0, sizeof (str));
  strncpy (str, (char *)ibuf.product, sizeof(ibuf.product));
  strncpy (str + sizeof(ibuf.revision), (char *)ibuf.revision, sizeof(ibuf.revision));
  str[sizeof(ibuf.product) + sizeof(ibuf.revision)] = '\0';
  dev->sane.model = str;
  dev->sane.type = "flatbed scanner";

  DBG (5, "dev->sane.name = %s\n", dev->sane.name);
  DBG (5, "dev->sane.vendor = %s\n", dev->sane.vendor);
  DBG (5, "dev->sane.model = %s\n", dev->sane.model);
  DBG (5, "dev->sane.type = %s\n", dev->sane.type);

  dev->info.xres_default = _2btol(wbuf.x_res);
  dev->info.yres_default = _2btol(wbuf.y_res);
  dev->info.image_mode_default = wbuf.image_comp;

  /* if you throw the MRIF bit the brighness control reverses too */
  /* so I reverse the reversal in software for symmetry's sake */
  /* I should make this into an option */

  if (wbuf.image_comp == RICOH_GRAYSCALE || wbuf.image_comp == RICOH_DITHERED_MONOCHROME)
    {
      dev->info.brightness_default = 256 - wbuf.brightness;
      if (is50)
	dev->info.contrast_default = wbuf.contrast;
      else
	dev->info.contrast_default = 256 - wbuf.contrast;
    }
  else /* wbuf.image_comp == RICOH_BINARY_MONOCHROME */
    {
      dev->info.brightness_default = wbuf.brightness;
      dev->info.contrast_default = wbuf.contrast;
    }

#if 1
  dev->info.bmu = mup.bmu;
  dev->info.mud = _2btol(mup.mud);
  if (dev->info.mud == 0) {
    /* The RICOH says it uses points as default Basic Measurement Unit */
    /* but gives a Measurement Unit Divisor of zero */
    /* So, we set it to the default (SCSI-standard) of 1200 */
    /* with BMU in inches, i.e. 1200 points equal 1 inch */
    dev->info.bmu = INCHES;
    dev->info.mud = DEFAULT_MUD;
  }
#else
    dev->info.bmu = INCHES;
    dev->info.mud = DEFAULT_MUD;
#endif

  DBG (5, "xres_default=%d\n", dev->info.xres_default);
  DBG (5, "xres_range.max=%d\n", dev->info.xres_range.max);
  DBG (5, "xres_range.min=%d\n", dev->info.xres_range.min);

  DBG (5, "yres_default=%d\n", dev->info.yres_default);
  DBG (5, "yres_range.max=%d\n", dev->info.yres_range.max);
  DBG (5, "yres_range.min=%d\n", dev->info.yres_range.min);

  DBG (5, "x_range.max=%d\n", dev->info.x_range.max);
  DBG (5, "y_range.max=%d\n", dev->info.y_range.max);

  DBG (5, "image_mode=%d\n", dev->info.image_mode_default);

  DBG (5, "brightness=%d\n", dev->info.brightness_default);
  DBG (5, "contrast=%d\n", dev->info.contrast_default);

  DBG (5, "bmu=%d\n", dev->info.bmu);
  DBG (5, "mud=%d\n", dev->info.mud);

  ++num_devices;
  dev->next = first_dev;
  first_dev = dev;

  if (devp)
    *devp = dev;

  DBG (11, "<< attach\n");
  return (SANE_STATUS_GOOD);
}
예제 #22
0
파일: callbacks.c 프로젝트: iolo/liteamp
void on_preferences_activate(GtkAction * action, gpointer user_data)
{
    PrefsDialog *dialog;
    dialog = prefs_dialog_new(get_window(app));
    prefs_dialog_show(dialog, &prefs);
}
예제 #23
0
void ScreenArea::vShowCursor()
{
    get_window()->set_cursor();
    m_bShowCursor = true;
}
예제 #24
0
tdialog* twidget::dialog()
{
	twindow* window = get_window();
	return window ? window->dialog() : NULL;
}
예제 #25
0
void handle_msg(int *msg)
{
	WINDOWP	window;

	wake_mouse();
	window= get_window(msg[3]);			/* Zugeh�riges Fenster */

	switch (msg[0])							/* Art der Nachricht */
	{
		case MN_SELECTED:
			if (makro_rec)						/* Makro wird Tastendruck vorgegaukelt */
			{
				int	kstate, kreturn;
				char	str[50];
				
				get_string(menu, msg[4], str);
				if (str_to_key(str, &kstate, &kreturn))
				{
					kstate |= (kstate & 3);
					to_makro(kstate, kreturn);
				}
			}
			handle_menu(msg[3], msg[4], menu_ctrl);
			menu_ctrl = FALSE;
			break;
		case WM_REDRAW  :
			if (msg[3] == akt_handle)
				redraw_aktion();
			else
				redraw_window (window, (GRECT*)(msg+4));
			break;
		case WM_CLOSED  :
			do_icon(window->handle, DO_DELETE);
			break;
		case WM_FULLED  :
			full_window (window);
			break;
		case WM_ARROWED :
			arrow_window (window, msg[4], 1);
			break;
		case WM_HSLID	 :
			h_slider (window, msg[4]);
			break;
		case WM_VSLID	 :
			v_slider (window, msg[4]);
			break;
		case WM_SIZED	 :
			size_window (window, (GRECT*)(msg+4), TRUE);
			break;
		case WM_MOVED	 :
			move_window (window, (GRECT*)(msg+4));
			break;
		case WM_NEWTOP	 : /* Fenster von qed ist irgendwie nach oben gekommen */
		case WM_ONTOP	 :
			ontop_window(window);
			break;
		case WM_TOPPED  :
			top_window (window);
			break;
		case WM_UNTOPPED: /* qed hat jetzt nicht mehr das Top-Fenster */
			untop_window (window);
			break;
		case WM_BOTTOMED: 	/* AES 4.00 MagiC 3 : Fenster nach hinten */
		case WM_M_BDROPPED :	/* Magic 2 */
			bottom_window (window, msg[0]);
			break;
		case WM_ICONIFY:
			iconify_window(window, (GRECT*)(msg+4));
			break;
		case WM_ALLICONIFY:
			all_iconify(window, (GRECT*)(msg+4));
			break;
		case WM_UNICONIFY:
			if (all_iconified)
				all_uniconify(NULL, (GRECT*)(msg+4));
			else
				uniconify_window(window, (GRECT*)(msg+4));
			break;
		case WM_SHADED :
		case WM_UNSHADED :
			shade_window(window, msg[0]);
			break;

		case AP_TERM:
			if (all_iconified)
				all_uniconify(NULL, NULL);
			quick_close = TRUE;
			if (prepare_quit())
				do_quit();
			break;
		case AP_DRAGDROP :
			if (all_iconified)
				Bconout(2, 7);
			else
				handle_dd(msg);
			break;

		case SC_CHANGED :
			/*
			 * Ignorieren, da wir vor dem Paste sowieso neu laden.
			*/
			break;

		case VA_START :
		case VA_PROTOSTATUS :
		case VA_DRAG_COMPLETE :
		case VA_DRAGACCWIND :
		case AV_SENDKEY :
			handle_av(msg);
			break;

		case SE_INIT:
		case SE_OK:
		case SE_ACK:
		case SE_OPEN:
		case SE_ERROR:
		case SE_ERRFILE:
		case SE_PROJECT:
		case SE_QUIT:
		case SE_TERMINATE:
		case SE_CLOSE :
		case SE_MENU :
			if (all_iconified)
				all_uniconify(NULL, NULL);
		   handle_se(msg);
		   break;

		case OLGA_INIT :
		case OLE_NEW :
		case OLGA_ACK :
		case OLE_EXIT :
			handle_olga(msg);
			break;

		case SH_WDRAW:				/* schickt Freedom st�ndig */
		case DHST_ACK:				/* SMU antwortet */
			/* ignore */
			break;

		case FONT_CHANGED :
			if (msg[4] != 0)
				font_id = msg[4];
			if (msg[5] != 0)
				font_pts = msg[5];
			font_change();	
			break;
			
		default:
			if (debug_level)
			{
				char	str[12];
				int	d, i, id;
	
				if ((appl_xgetinfo(4, &d, &d, &i, &d)) && (i == 1))	/* gibts appl_search? */
				{
					i = appl_search(0, str, &d, &id);
					while (i != 0)
					{
						if (id == msg[1])
							break;
						i = appl_search( 1, str, &d, &id);
					}
				}
				else
				{
					strcpy(str, "");
					id = msg[1];
				}
				debug("Unbekannte Msg %d (0x%X) von %s (%d)\n", msg[0], msg[0], str, id);
			}
			break;
	}
}
예제 #26
0
	/// Invalidate whole window.
	void invalidate() {
		get_window()->invalidate_rect(get_allocation(), false);
	}
예제 #27
0
  void Video_GL::init() {
    std::cout << "Initializing OpenGL" << std::endl;

    //double buffer, no stencil, no accumulation buffer
    SDL_GL_SetAttribute(SDL_GL_RED_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, 8);
    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 16);
    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
    SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 0);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, 0);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, 0);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, 0);
    SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, 0);

    if(get_multisampling() > 1) {
      SDL_GL_SetAttribute (SDL_GL_MULTISAMPLESAMPLES, get_multisampling());
      SDL_GL_SetAttribute (SDL_GL_MULTISAMPLEBUFFERS, 1);
    }

    set_opengl_flag(true);
    Video::init();

#if SDL_VERSION_ATLEAST(1,3,0)
    m_context = SDL_GL_CreateContext(get_window());
#endif

    {
      const GLenum err = glewInit();
      if(GLEW_OK != err) {
        std::cerr << "GLEW Error: " << glewGetErrorString(err) << std::endl;
        throw Video_Init_Failure();
      }
    }

    // Set Fill/Shade Mode
    glShadeModel(GL_SMOOTH);
    glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
    glEnable(GL_NORMALIZE); //GL_RESCALE_NORMALIZE);

    // Enable Alpha Blitting
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
    //glBlendEquation(GL_FUNC_ADD); // default // would require ARB ext

    // Set lighting variables
    glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE);
    glLightModeli(GL_LIGHT_MODEL_COLOR_CONTROL, GL_SEPARATE_SPECULAR_COLOR);
    if(glGetError() == GL_INVALID_ENUM)
      std::cerr << "Quality Warning:  Your graphics card does not support separate specular lighting in OpenGL.\n";

    // Initialize Assorted Variables
    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
    //glPointSize(static_cast<GLfloat>(sqrt(pow(double(get_screen_width()), 2.) * pow(double(get_screen_height()), 2.)) / 1000000));
    //glLineWidth(static_cast<GLfloat>(sqrt(pow(double(get_screen_width()), 2.) * pow(double(get_screen_height()), 2.)) / 1000000));

    // Finish with a few function calls
    set_2d();
    set_color(get_color());
    set_clear_color(get_clear_color());
    set_backface_culling(get_backface_culling());
    set_lighting(get_lighting());
    set_ambient_lighting(get_ambient_lighting());
    set_alpha_test(is_alpha_test_enabled(), get_alpha_test_function(), get_alpha_test_value());
    set_zwrite(is_zwrite_enabled());
    set_ztest(is_ztest_enabled());

    union {
      void * v;
#ifdef _LINUX
      PFNGLXSWAPINTERVALEXTPROC pglSwapIntervalEXT;
      PFNGLXSWAPINTERVALSGIPROC pglSwapIntervalSGI;
#endif
      PFNGLBINDBUFFERARBPROC pglBindBufferARB;
      PFNGLDELETEBUFFERSARBPROC pglDeleteBuffersARB;
      PFNGLGENBUFFERSARBPROC pglGenBuffersARB;
      PFNGLBUFFERDATAARBPROC pglBufferDataARB;
    } ptr;

#ifdef _LINUX
    ptr.v = SDL_GL_GetProcAddress("glXSwapIntervalEXT");
    if(!ptr.v)
      ptr.v = SDL_GL_GetProcAddress("wglSwapIntervalEXT");
    m_pglSwapIntervalEXT = ptr.pglSwapIntervalEXT;

    ptr.v = SDL_GL_GetProcAddress("glXSwapIntervalSGI");
    if(!ptr.v)
      ptr.v = SDL_GL_GetProcAddress("wglSwapIntervalSGI");
    m_pglSwapIntervalSGI = ptr.pglSwapIntervalSGI;
#endif

    // Has to be done after finding the function pointer
    set_vertical_sync(get_vertical_sync());

    m_vertex_buffers = strstr(reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS)), "ARB_vertex_buffer_object") != 0;
    if(m_vertex_buffers) {
      ptr.v = SDL_GL_GetProcAddress("glBindBufferARB");
      m_pglBindBufferARB = ptr.pglBindBufferARB;

      ptr.v = SDL_GL_GetProcAddress("glDeleteBuffersARB");
      m_pglDeleteBuffersARB = ptr.pglDeleteBuffersARB;

      ptr.v = SDL_GL_GetProcAddress("glGenBuffersARB");
      m_pglGenBuffersARB = ptr.pglGenBuffersARB;

      ptr.v = SDL_GL_GetProcAddress("glBufferDataARB");
      m_pglBufferDataARB = ptr.pglBufferDataARB;
    }
    else
      std::cerr << "Performance Warning:  Your graphics card does not offer Vertex Buffer Objects (VBO) in OpenGL.\n";

    if(strstr((char*)glGetString(GL_EXTENSIONS), "GL_EXT_texture_filter_anisotropic"))
      glGetIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, reinterpret_cast<GLint *>(&m_maximum_anisotropy));
    else
      m_maximum_anisotropy = 0;
  }
예제 #28
0
/**
 Escribe los datos referentes a cada separacion de cada uno de los ejes del histograma
 @param dx, desplazamiento en el eje X cuando cambiamos el tamaño de la ventana
 @param dy, desplazamiento en el eje Y cuando cambiamos el tamaño de la ventana
 */
void PlotHistogram::pintaTextoPango(int dx, int dy)
{
	double ejeX, ejeY, incX, incY, actX, actY;
	double scala;
	double numYcorrect;
	int contX;

	scala = -25.0;

	ejeX = anchoPlot -100;
	incX = ejeX / numX;
	ejeY = altoPlot - 100;
	incY = ejeY / 10;

	actX = 75;
	actY = 375;

	layout->set_font_description(*timesnr_8);

	contX = -1;
	//Rellenado de nombres
	while(actX <= 705)
	{
		scala = scala + 25;		
		contX++;

		if(scala == 0)
		{
			layout->set_markup(Utiles::converString(scala));
			get_window()->draw_layout(Gdk::GC::create(get_window()), 
				        actX + 15, actY + dy + 20, layout);
		}
		else if(contX == 4)
		{
			layout->set_markup(Utiles::converString(scala));
			get_window()->draw_layout(Gdk::GC::create(get_window()), 
				        actX + 10, actY + dy + 20, layout);

			contX = 0;
		}
		
		actX = actX + incX;
	}

	actX = 75;
	numYcorrect = numY/10;
	//Ajustamos la escala para el numero mayor
	scala = numYcorrect - (2 * numYcorrect);
	
	//Pintamos las separaciones del ejeY
	while(actY >= 25)
	{
		scala = scala + numYcorrect;
		layout->set_markup(Utiles::converString(Utiles::redondearNDecimales(scala, 3)));
		get_window()->draw_layout(Gdk::GC::create(get_window()), 
				        actX - 20, actY - 5 + dy, layout);

		actY = actY - incY;
	}

	//Pintamos las referencias del histograma
	layout->set_font_description(*caligua_20_V);
	//Eje X
	layout->set_markup("Oocyte diameter (um)");
	get_window()->draw_layout(Gdk::GC::create(get_window()), 250 + dx, 410 + dy, layout);
	//Eje y
	layout->set_markup("Freq.");
	get_window()->draw_layout(Gdk::GC::create(get_window()), 5, 170 + dy, layout);
	
}
예제 #29
0
bool ImageDrawingArea::on_expose_event( GdkEventExpose* /*event*/ )
{
    if ( m_pixBuf == NULL )
    {
        return true;
    }

    Glib::Mutex::Lock lock(m_pixBufMutex);

    const int width = m_pixBuf->get_width();
    const int height = m_pixBuf->get_height();
    double validTextureWidth = 1.0;
    double validTextureHeight = 1.0;
    bool useTiledTextures = false;
    GLenum errorno;

    BeginGL();

    SetImageSize( width, height );

    int screenWidth = 0;
    int screenHeight = 0;
    get_window()->get_size( screenWidth, screenHeight );

    // This makes sure that sampling for rendering doesn't occur on the border of pixels.
    const double halfPixelAdjustW = 0.25 / (double)screenWidth;
    const double halfPixelAdjustH = 0.25 / (double)screenHeight;

    glEnable( GL_TEXTURE_2D );
    glMatrixMode( GL_MODELVIEW );
    glLoadIdentity();

    // center the image
    glTranslated(
        -(m_scaleX - 1.0)/2.0 + halfPixelAdjustW,
        -(m_scaleY - 1.0)/2.0 + halfPixelAdjustH, 0.0);

    // apply mouse-drag shift
    glTranslated(m_shiftX, m_shiftY, 0.0);

    // scale the image
    glScaled(m_scaleX, m_scaleY, 0.0);

    // draw the image
    glBindTexture(GL_TEXTURE_2D, m_imageTextures[0]);

#ifdef _WIN32
    if (m_PBOSupported)
    {
        glBindBufferARB(GL_PIXEL_UNPACK_BUFFER_ARB, m_PBO);
        errorno = glGetError();

        if (errorno != GL_NO_ERROR)
        {
            m_PBOSupported = false;
        }
        else
        {
            glBufferDataARB(
                GL_PIXEL_UNPACK_BUFFER_ARB,
                width * height * 4,
                m_pixBuf->get_pixels(),
                GL_STREAM_DRAW_ARB);
            errorno = glGetError();

            if (errorno != GL_NO_ERROR)
            {
                m_PBOSupported = false;
            }
        }
    }
#endif

    glTexImage2D(
        GL_TEXTURE_2D,
        0,
        GL_RGBA,
        width,
        height,
        0,
        GL_BGRA_EXT,
        GL_UNSIGNED_BYTE,
        m_PBOSupported ? NULL : m_pixBuf->get_pixels() );
    errorno = glGetError();

    if (errorno != GL_NO_ERROR)
    {
        // Attempt to fall back and use a power-of-two sized texture.
        // This is for older cards that don't support more arbitrary
        // texture sizes.

#ifdef _WIN32
        if (m_PBOSupported)
        {
            // unbind PBO to use normal texture transfer
            glBindBufferARB( GL_PIXEL_UNPACK_BUFFER_ARB, 0);
        }
#endif

        const int textureWidth = GetMinimumPowerOfTwo(width);
        const int textureHeight = GetMinimumPowerOfTwo(height);
        validTextureWidth = (double)width / textureWidth;
        validTextureHeight = (double)height / textureHeight;

        glTexImage2D(
            GL_TEXTURE_2D,
            0,
            GL_RGBA,
            textureWidth,
            textureHeight,
            0,
            GL_BGRA_EXT,
            GL_UNSIGNED_BYTE,
            NULL );
        errorno = glGetError();
        if (errorno != GL_NO_ERROR)
        {
            // The graphics doesn't seem to support this texture size.
            // Images must be split and then tiled.
            useTiledTextures = true;
        }
        else
        {
            glTexSubImage2D(
                GL_TEXTURE_2D,
                0,
                0,
                0,
                width,
                height,
                GL_BGRA_EXT,
                GL_UNSIGNED_BYTE,
                m_pixBuf->get_pixels() );
            errorno = glGetError();
            if ( errorno != GL_NO_ERROR)
            {
                // Error
            }
        }
    }

    if (useTiledTextures)
    {
        //
        // The image is split into multiple textures.
        //
        const int bytesPerPixel = 4;
        const int tileSize = 1024;
        int horizResidual = width % tileSize;
        int vertResidual = height % tileSize;
        int numHorizTextures = width / tileSize + (horizResidual > 0);
        int numVertTextures = height / tileSize + (vertResidual > 0);

        unsigned char *tileBuffer = new unsigned char[tileSize * tileSize * bytesPerPixel];

        for (int tileY = 0; tileY < numVertTextures ; tileY++)
        {
            for (int tileX = 0; tileX < numHorizTextures; tileX++)
            {
                int subTexHeight = tileSize;
                if ( tileY == numVertTextures - 1 && vertResidual > 0)
                {
                    subTexHeight = vertResidual;
                }

                int subTexWidth = tileSize;
                if (tileX == numHorizTextures - 1 && horizResidual > 0)
                {
                    subTexWidth = horizResidual;
                }

                // copy image buffer to the tile
                for (int line = 0; line < subTexHeight; line++)
                {
                    memcpy(
                        tileBuffer + line * tileSize * bytesPerPixel,
                        m_pixBuf->get_pixels() + ((line + tileSize * tileY) * width + tileSize * tileX) * bytesPerPixel,
                        subTexWidth * bytesPerPixel);
                }

                const unsigned int texId = tileY * numHorizTextures + tileX;
                if (texId >= sk_maxNumTextures)
                {
                    continue;
                }

                glBindTexture( GL_TEXTURE_2D, m_imageTextures[ texId] );
                glTexImage2D(
                    GL_TEXTURE_2D,
                    0,
                    GL_RGBA,
                    tileSize,
                    tileSize,
                    0,
                    GL_BGRA_EXT,
                    GL_UNSIGNED_BYTE,
                    tileBuffer );

                const double validTileWidth = (double)subTexWidth/tileSize;
                const double validTileHeight = (double)subTexHeight/tileSize;

                const double x_begin = (double)tileSize / width * tileX;
                const double x_end = (double)tileSize / width * ( tileX + validTileWidth);
                const double y_begin = 1.0 - (double)tileSize / height * ( tileY + validTileHeight);
                const double y_end = 1.0 - (double)tileSize / height * tileY;

                glBegin( GL_QUADS );

                glTexCoord2d(0.0, validTileHeight);
                glVertex2d(x_begin, y_begin);

                glTexCoord2d(validTileWidth, validTileHeight);
                glVertex2d(x_end, y_begin);

                glTexCoord2d(validTileWidth, 0.0);
                glVertex2d(x_end, y_end);

                glTexCoord2d(0.0, 0.0);
                glVertex2d(x_begin, y_end);

                glEnd();
            }
        }

        delete [] tileBuffer;
    }
    else
    {
        // Just one texture
        glBegin( GL_QUADS );

        glTexCoord2d(0.0, validTextureHeight);
        glVertex2d(0.0, 0.0);

        glTexCoord2d(validTextureWidth, validTextureHeight);
        glVertex2d(1.0, 0.0);

        glTexCoord2d(validTextureWidth, 0.0);
        glVertex2d(1.0, 1.0);

        glTexCoord2d(0.0, 0.0);
        glVertex2d(0.0, 1.0);

        glEnd();
    }

    if ( m_showCrosshair )
    {
        const double aspectRatio = (double)width/height;
        glTranslated(0.5, 0.5, 0.0);
        glScaled(1.0, aspectRatio, 0.0);
        ShowCrosshair();
    }

    if (get_gl_window()->is_double_buffered())
    {
        get_gl_window()->swap_buffers();
    }
    else
    {
        glFlush();
    }

    EndGL();

    lock.release();

    m_displayedFrameRate.NewFrame();

    return true;
}
예제 #30
0
void tscroll_label::signal_handler_left_button_down(const event::tevent event)
{
	DBG_GUI_E << LOG_HEADER << ' ' << event << ".\n";

	get_window()->keyboard_capture(this);
}